librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  48 {
  49         ndr_print_struct(ndr, name, "spoolss_Time");
  50         ndr->depth++;
  51         ndr_print_uint16(ndr, "year", r->year);
  52         ndr_print_uint16(ndr, "month", r->month);
  53         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  54         ndr_print_uint16(ndr, "day", r->day);
  55         ndr_print_uint16(ndr, "hour", r->hour);
  56         ndr_print_uint16(ndr, "minute", r->minute);
  57         ndr_print_uint16(ndr, "second", r->second);
  58         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  59         ndr->depth--;
  60 }
  61
  62 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  63 {
  64         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  65 }
  66
  67 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  68 {
  69         if (ndr_flags & NDR_SCALARS) {
  70                 NDR_CHECK(ndr_push_align(ndr, 5));
  71                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  72                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  73                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  74         }
  75         if (ndr_flags & NDR_BUFFERS) {
  76                 if (r->time) {
  77                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  78                 }
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  84 {
  85         uint32_t _ptr_time;
  86         TALLOC_CTX *_mem_save_time_0;
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_pull_align(ndr, 5));
  89                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  90                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  91                 if (_ptr_time) {
  92                         NDR_PULL_ALLOC(ndr, r->time);
  93                 } else {
  94                         r->time = NULL;
  95                 }
  96                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  97         }
  98         if (ndr_flags & NDR_BUFFERS) {
  99                 if (r->time) {
 100                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
 101                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
 102                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
 103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 110 {
 111         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 112         ndr->depth++;
 113         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 114         ndr_print_ptr(ndr, "time", r->time);
 115         ndr->depth++;
 116         if (r->time) {
 117                 ndr_print_spoolss_Time(ndr, "time", r->time);
 118         }
 119         ndr->depth--;
 120         ndr->depth--;
 121 }
 122
 123 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 124 {
 125         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 130 {
 131         uint16_t v;
 132         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 133         *r = v;
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 143                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 144                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 145         }
 146         ndr_print_enum(ndr, name, "ENUM", val, r);
 147 }
 148
 149 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 150 {
 151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 152         return NDR_ERR_SUCCESS;
 153 }
 154
 155 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 156 {
 157         uint32_t v;
 158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 159         *r = v;
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 164 {
 165         const char *val = NULL;
 166
 167         switch (r) {
 168                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 169                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 170                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 171                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 172                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 173         }
 174         ndr_print_enum(ndr, name, "ENUM", val, r);
 175 }
 176
 177 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 178 {
 179         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 184 {
 185         uint32_t v;
 186         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 187         *r = v;
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 192 {
 193         const char *val = NULL;
 194
 195         switch (r) {
 196                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 197                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 198                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 199         }
 200         ndr_print_enum(ndr, name, "ENUM", val, r);
 201 }
 202
 203 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 204 {
 205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 210 {
 211         uint32_t v;
 212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 213         *r = v;
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 218 {
 219         const char *val = NULL;
 220
 221         switch (r) {
 222                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 223                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 224                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 225                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 226                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 227         }
 228         ndr_print_enum(ndr, name, "ENUM", val, r);
 229 }
 230
 231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 232 {
 233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 238 {
 239         uint32_t v;
 240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 241         *r = v;
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 246 {
 247         ndr_print_uint32(ndr, name, r);
 248         ndr->depth++;
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 274         ndr->depth--;
 275 }
 276
 277 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 278 {
 279         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 284 {
 285         uint32_t v;
 286         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 287         *r = v;
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 292 {
 293         ndr_print_uint32(ndr, name, r);
 294         ndr->depth++;
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 308         ndr->depth--;
 309 }
 310
 311 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 312 {
 313         if (ndr_flags & NDR_SCALARS) {
 314                 NDR_CHECK(ndr_push_align(ndr, 5));
 315                 {
 316                         uint32_t _flags_save_string = ndr->flags;
 317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 319                         ndr->flags = _flags_save_string;
 320                 }
 321                 {
 322                         uint32_t _flags_save_string = ndr->flags;
 323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 325                         ndr->flags = _flags_save_string;
 326                 }
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 330                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 340                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 342                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 346                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 349                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 354                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 355         }
 356         if (ndr_flags & NDR_BUFFERS) {
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 360                         if (r->printername) {
 361                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
 364                         }
 365                         ndr->flags = _flags_save_string;
 366                 }
 367                 {
 368                         uint32_t _flags_save_string = ndr->flags;
 369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 370                         if (r->servername) {
 371                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
 372                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 373                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
 374                         }
 375                         ndr->flags = _flags_save_string;
 376                 }
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 382 {
 383         uint32_t _ptr_printername;
 384         TALLOC_CTX *_mem_save_printername_0;
 385         uint32_t _ptr_servername;
 386         TALLOC_CTX *_mem_save_servername_0;
 387         if (ndr_flags & NDR_SCALARS) {
 388                 NDR_CHECK(ndr_pull_align(ndr, 5));
 389                 {
 390                         uint32_t _flags_save_string = ndr->flags;
 391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 393                         if (_ptr_printername) {
 394                                 NDR_PULL_ALLOC(ndr, r->printername);
 395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 396                         } else {
 397                                 r->printername = NULL;
 398                         }
 399                         ndr->flags = _flags_save_string;
 400                 }
 401                 {
 402                         uint32_t _flags_save_string = ndr->flags;
 403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 405                         if (_ptr_servername) {
 406                                 NDR_PULL_ALLOC(ndr, r->servername);
 407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 408                         } else {
 409                                 r->servername = NULL;
 410                         }
 411                         ndr->flags = _flags_save_string;
 412                 }
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 416                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 426                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 431                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 432                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 435                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 436                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 440                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 441         }
 442         if (ndr_flags & NDR_BUFFERS) {
 443                 {
 444                         uint32_t _flags_save_string = ndr->flags;
 445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 446                         if (r->printername) {
 447                                 uint32_t _relative_save_offset;
 448                                 _relative_save_offset = ndr->offset;
 449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 450                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 451                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 454                                 if (ndr->offset > ndr->relative_highest_offset) {
 455                                         ndr->relative_highest_offset = ndr->offset;
 456                                 }
 457                                 ndr->offset = _relative_save_offset;
 458                         }
 459                         ndr->flags = _flags_save_string;
 460                 }
 461                 {
 462                         uint32_t _flags_save_string = ndr->flags;
 463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 464                         if (r->servername) {
 465                                 uint32_t _relative_save_offset;
 466                                 _relative_save_offset = ndr->offset;
 467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 468                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 469                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 472                                 if (ndr->offset > ndr->relative_highest_offset) {
 473                                         ndr->relative_highest_offset = ndr->offset;
 474                                 }
 475                                 ndr->offset = _relative_save_offset;
 476                         }
 477                         ndr->flags = _flags_save_string;
 478                 }
 479         }
 480         return NDR_ERR_SUCCESS;
 481 }
 482
 483 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 484 {
 485         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 486         ndr->depth++;
 487         ndr_print_ptr(ndr, "printername", r->printername);
 488         ndr->depth++;
 489         if (r->printername) {
 490                 ndr_print_string(ndr, "printername", r->printername);
 491         }
 492         ndr->depth--;
 493         ndr_print_ptr(ndr, "servername", r->servername);
 494         ndr->depth++;
 495         if (r->servername) {
 496                 ndr_print_string(ndr, "servername", r->servername);
 497         }
 498         ndr->depth--;
 499         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 500         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 501         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 502         ndr_print_spoolss_Time(ndr, "time", &r->time);
 503         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 504         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 505         ndr_print_uint32(ndr, "version", r->version);
 506         ndr_print_uint32(ndr, "free_build", r->free_build);
 507         ndr_print_uint32(ndr, "spooling", r->spooling);
 508         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 509         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 510         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 511         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 512         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 513         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 514         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 515         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 516         ndr_print_uint32(ndr, "change_id", r->change_id);
 517         ndr_print_WERROR(ndr, "last_error", r->last_error);
 518         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 519         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 520         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 521         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 522         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 523         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 524         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 525         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 526         ndr->depth--;
 527 }
 528
 529 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 530 {
 531         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 532 }
 533
 534 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 535 {
 536         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 537         return NDR_ERR_SUCCESS;
 538 }
 539
 540 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 541 {
 542         uint32_t v;
 543         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 544         *r = v;
 545         return NDR_ERR_SUCCESS;
 546 }
 547
 548 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 549 {
 550         ndr_print_uint32(ndr, name, r);
 551         ndr->depth++;
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 578         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 580         ndr->depth--;
 581 }
 582
 583 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 584 {
 585         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 586         return NDR_ERR_SUCCESS;
 587 }
 588
 589 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 590 {
 591         uint16_t v;
 592         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 593         *r = v;
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 598 {
 599         const char *val = NULL;
 600
 601         switch (r) {
 602                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 603                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 604                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 605         }
 606         ndr_print_enum(ndr, name, "ENUM", val, r);
 607 }
 608
 609 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 610 {
 611         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 612         return NDR_ERR_SUCCESS;
 613 }
 614
 615 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 616 {
 617         uint16_t v;
 618         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 619         *r = v;
 620         return NDR_ERR_SUCCESS;
 621 }
 622
 623 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 624 {
 625         const char *val = NULL;
 626
 627         switch (r) {
 628                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 629                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 630         }
 631         ndr_print_enum(ndr, name, "ENUM", val, r);
 632 }
 633
 634 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 635 {
 636         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 637         return NDR_ERR_SUCCESS;
 638 }
 639
 640 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 641 {
 642         uint16_t v;
 643         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 644         *r = v;
 645         return NDR_ERR_SUCCESS;
 646 }
 647
 648 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 649 {
 650         const char *val = NULL;
 651
 652         switch (r) {
 653                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 654                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 655                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 656                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 657                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 658                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 659                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 660                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 661                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 662                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 663                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 664                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 665                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 666                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 667                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 668                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 669                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 670                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 671                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 672                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 673                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 674                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 675                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 676                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 677                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 678                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 679                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 680                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 681                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 682                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 683                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 684                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 685                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 686                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 687                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 688                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 689                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 690                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 691                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 692                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 693                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 694                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 695                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 696                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 697                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 698                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 699                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 700                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 701                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 702                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 703                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 704                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 705                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 706                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 707                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 708                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 709                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 710                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 711                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 712                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 713                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 714                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 715                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 716                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 717                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 718                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 719                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 720                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 721                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 722                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 723                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 724                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 725                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 726                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 727                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 728                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 729                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 730                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 731                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 732                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 733                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 734                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 735                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 736                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 737                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 738                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 739                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 740                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 741                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 742                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 743                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 744         }
 745         ndr_print_enum(ndr, name, "ENUM", val, r);
 746 }
 747
 748 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 749 {
 750         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 751         return NDR_ERR_SUCCESS;
 752 }
 753
 754 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 755 {
 756         uint16_t v;
 757         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 758         *r = v;
 759         return NDR_ERR_SUCCESS;
 760 }
 761
 762 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 763 {
 764         const char *val = NULL;
 765
 766         switch (r) {
 767                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 768                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 769                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 770                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 771                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 772                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 773                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 774                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 775                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 776                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 777                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 778                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 779                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 780         }
 781         ndr_print_enum(ndr, name, "ENUM", val, r);
 782 }
 783
 784 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 785 {
 786         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 787         return NDR_ERR_SUCCESS;
 788 }
 789
 790 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 791 {
 792         uint16_t v;
 793         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 794         *r = v;
 795         return NDR_ERR_SUCCESS;
 796 }
 797
 798 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 799 {
 800         const char *val = NULL;
 801
 802         switch (r) {
 803                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 804                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 805                 case DMRES_LOW: val = "DMRES_LOW"; break;
 806                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 807         }
 808         ndr_print_enum(ndr, name, "ENUM", val, r);
 809 }
 810
 811 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 812 {
 813         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 818 {
 819         uint16_t v;
 820         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 821         *r = v;
 822         return NDR_ERR_SUCCESS;
 823 }
 824
 825 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 826 {
 827         const char *val = NULL;
 828
 829         switch (r) {
 830                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 831                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 832         }
 833         ndr_print_enum(ndr, name, "ENUM", val, r);
 834 }
 835
 836 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 837 {
 838         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 839         return NDR_ERR_SUCCESS;
 840 }
 841
 842 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 843 {
 844         uint16_t v;
 845         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 846         *r = v;
 847         return NDR_ERR_SUCCESS;
 848 }
 849
 850 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 851 {
 852         const char *val = NULL;
 853
 854         switch (r) {
 855                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 856                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 857                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 858         }
 859         ndr_print_enum(ndr, name, "ENUM", val, r);
 860 }
 861
 862 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 863 {
 864         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 865         return NDR_ERR_SUCCESS;
 866 }
 867
 868 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 869 {
 870         uint16_t v;
 871         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 872         *r = v;
 873         return NDR_ERR_SUCCESS;
 874 }
 875
 876 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 877 {
 878         const char *val = NULL;
 879
 880         switch (r) {
 881                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 882                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 883                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 884                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 885         }
 886         ndr_print_enum(ndr, name, "ENUM", val, r);
 887 }
 888
 889 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 890 {
 891         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 892         return NDR_ERR_SUCCESS;
 893 }
 894
 895 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 896 {
 897         uint16_t v;
 898         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 899         *r = v;
 900         return NDR_ERR_SUCCESS;
 901 }
 902
 903 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 904 {
 905         const char *val = NULL;
 906
 907         switch (r) {
 908                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 909                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 910         }
 911         ndr_print_enum(ndr, name, "ENUM", val, r);
 912 }
 913
 914 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 915 {
 916         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 921 {
 922         uint32_t v;
 923         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 924         *r = v;
 925         return NDR_ERR_SUCCESS;
 926 }
 927
 928 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 929 {
 930         const char *val = NULL;
 931
 932         switch (r) {
 933                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 934                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 935         }
 936         ndr_print_enum(ndr, name, "ENUM", val, r);
 937 }
 938
 939 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 940 {
 941         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 946 {
 947         uint32_t v;
 948         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 949         *r = v;
 950         return NDR_ERR_SUCCESS;
 951 }
 952
 953 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 954 {
 955         const char *val = NULL;
 956
 957         switch (r) {
 958                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 959                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 960                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 961                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 962         }
 963         ndr_print_enum(ndr, name, "ENUM", val, r);
 964 }
 965
 966 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 967 {
 968         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 969         return NDR_ERR_SUCCESS;
 970 }
 971
 972 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 973 {
 974         uint32_t v;
 975         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 976         *r = v;
 977         return NDR_ERR_SUCCESS;
 978 }
 979
 980 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 981 {
 982         const char *val = NULL;
 983
 984         switch (r) {
 985                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 986                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 987                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 988                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 989         }
 990         ndr_print_enum(ndr, name, "ENUM", val, r);
 991 }
 992
 993 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 994 {
 995         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 996         return NDR_ERR_SUCCESS;
 997 }
 998
 999 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
1000 {
1001         uint32_t v;
1002         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1003         *r = v;
1004         return NDR_ERR_SUCCESS;
1005 }
1006
1007 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1008 {
1009         const char *val = NULL;
1010
1011         switch (r) {
1012                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1013                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1014                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1015         }
1016         ndr_print_enum(ndr, name, "ENUM", val, r);
1017 }
1018
1019 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1020 {
1021         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1022         return NDR_ERR_SUCCESS;
1023 }
1024
1025 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1026 {
1027         uint32_t v;
1028         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1029         *r = v;
1030         return NDR_ERR_SUCCESS;
1031 }
1032
1033 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1034 {
1035         const char *val = NULL;
1036
1037         switch (r) {
1038                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1039                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1040                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1041                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1042                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1043                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1044                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1045                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1046                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1047                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1048         }
1049         ndr_print_enum(ndr, name, "ENUM", val, r);
1050 }
1051
1052 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1053 {
1054         if (ndr_flags & NDR_SCALARS) {
1055                 NDR_CHECK(ndr_push_align(ndr, 4));
1056                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1057                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1059                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1060                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1062                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1063                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1066                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1067                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1070                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1072                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1073                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1074                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1075                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1076                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1080                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1082                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1083                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1084                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1085                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1090                 {
1091                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1093                         {
1094                                 struct ndr_push *_ndr_driverextra_data;
1095                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1096                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1097                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1098                         }
1099                         ndr->flags = _flags_save_DATA_BLOB;
1100                 }
1101                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1102         }
1103         if (ndr_flags & NDR_BUFFERS) {
1104         }
1105         return NDR_ERR_SUCCESS;
1106 }
1107
1108 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1109 {
1110         if (ndr_flags & NDR_SCALARS) {
1111                 NDR_CHECK(ndr_pull_align(ndr, 4));
1112                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1113                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1115                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1116                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1118                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1119                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1122                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1123                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1126                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1127                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1128                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1129                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1130                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1131                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1132                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1136                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1138                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1139                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1140                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1141                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1146                 {
1147                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1149                         {
1150                                 struct ndr_pull *_ndr_driverextra_data;
1151                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1152                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1153                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1154                         }
1155                         ndr->flags = _flags_save_DATA_BLOB;
1156                 }
1157                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1158         }
1159         if (ndr_flags & NDR_BUFFERS) {
1160         }
1161         return NDR_ERR_SUCCESS;
1162 }
1163
1164 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1165 {
1166         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1167         ndr->depth++;
1168         ndr_print_string(ndr, "devicename", r->devicename);
1169         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1170         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1171         ndr_print_uint16(ndr, "size", r->size);
1172         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1173         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1174         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1175         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1176         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1177         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1178         ndr_print_uint16(ndr, "scale", r->scale);
1179         ndr_print_uint16(ndr, "copies", r->copies);
1180         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1181         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1182         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1183         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1184         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1185         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1186         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1187         ndr_print_string(ndr, "formname", r->formname);
1188         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1189         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1190         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1191         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1192         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1193         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1194         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1195         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1196         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1197         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1198         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1199         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1200         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1201         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1202         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1203         ndr->depth--;
1204 }
1205
1206 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1207 {
1208         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1209 }
1210
1211 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1212 {
1213         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1214         return NDR_ERR_SUCCESS;
1215 }
1216
1217 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1218 {
1219         uint32_t v;
1220         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1221         *r = v;
1222         return NDR_ERR_SUCCESS;
1223 }
1224
1225 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1226 {
1227         ndr_print_uint32(ndr, name, r);
1228         ndr->depth++;
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1248         ndr->depth--;
1249 }
1250
1251 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1252 {
1253         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1258 {
1259         uint32_t v;
1260         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1261         *r = v;
1262         return NDR_ERR_SUCCESS;
1263 }
1264
1265 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1266 {
1267         ndr_print_uint32(ndr, name, r);
1268         ndr->depth++;
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1283         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1284         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1285         ndr->depth--;
1286 }
1287
1288 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1289 {
1290         if (ndr_flags & NDR_SCALARS) {
1291                 NDR_CHECK(ndr_push_align(ndr, 5));
1292                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1297                         ndr->flags = _flags_save_string;
1298                 }
1299                 {
1300                         uint32_t _flags_save_string = ndr->flags;
1301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 {
1306                         uint32_t _flags_save_string = ndr->flags;
1307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1308                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1309                         ndr->flags = _flags_save_string;
1310                 }
1311                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1312         }
1313         if (ndr_flags & NDR_BUFFERS) {
1314                 {
1315                         uint32_t _flags_save_string = ndr->flags;
1316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317                         if (r->description) {
1318                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1319                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1320                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         if (r->name) {
1328                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name));
1329                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1330                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name));
1331                         }
1332                         ndr->flags = _flags_save_string;
1333                 }
1334                 {
1335                         uint32_t _flags_save_string = ndr->flags;
1336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1337                         if (r->comment) {
1338                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1340                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1341                         }
1342                         ndr->flags = _flags_save_string;
1343                 }
1344         }
1345         return NDR_ERR_SUCCESS;
1346 }
1347
1348 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1349 {
1350         uint32_t _ptr_description;
1351         TALLOC_CTX *_mem_save_description_0;
1352         uint32_t _ptr_name;
1353         TALLOC_CTX *_mem_save_name_0;
1354         uint32_t _ptr_comment;
1355         TALLOC_CTX *_mem_save_comment_0;
1356         if (ndr_flags & NDR_SCALARS) {
1357                 NDR_CHECK(ndr_pull_align(ndr, 5));
1358                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1359                 {
1360                         uint32_t _flags_save_string = ndr->flags;
1361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1362                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1363                         if (_ptr_description) {
1364                                 NDR_PULL_ALLOC(ndr, r->description);
1365                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1366                         } else {
1367                                 r->description = NULL;
1368                         }
1369                         ndr->flags = _flags_save_string;
1370                 }
1371                 {
1372                         uint32_t _flags_save_string = ndr->flags;
1373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1374                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1375                         if (_ptr_name) {
1376                                 NDR_PULL_ALLOC(ndr, r->name);
1377                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1378                         } else {
1379                                 r->name = NULL;
1380                         }
1381                         ndr->flags = _flags_save_string;
1382                 }
1383                 {
1384                         uint32_t _flags_save_string = ndr->flags;
1385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1386                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1387                         if (_ptr_comment) {
1388                                 NDR_PULL_ALLOC(ndr, r->comment);
1389                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1390                         } else {
1391                                 r->comment = NULL;
1392                         }
1393                         ndr->flags = _flags_save_string;
1394                 }
1395                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1396         }
1397         if (ndr_flags & NDR_BUFFERS) {
1398                 {
1399                         uint32_t _flags_save_string = ndr->flags;
1400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1401                         if (r->description) {
1402                                 uint32_t _relative_save_offset;
1403                                 _relative_save_offset = ndr->offset;
1404                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1405                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1406                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1407                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1408                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1409                                 if (ndr->offset > ndr->relative_highest_offset) {
1410                                         ndr->relative_highest_offset = ndr->offset;
1411                                 }
1412                                 ndr->offset = _relative_save_offset;
1413                         }
1414                         ndr->flags = _flags_save_string;
1415                 }
1416                 {
1417                         uint32_t _flags_save_string = ndr->flags;
1418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1419                         if (r->name) {
1420                                 uint32_t _relative_save_offset;
1421                                 _relative_save_offset = ndr->offset;
1422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1423                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1424                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1427                                 if (ndr->offset > ndr->relative_highest_offset) {
1428                                         ndr->relative_highest_offset = ndr->offset;
1429                                 }
1430                                 ndr->offset = _relative_save_offset;
1431                         }
1432                         ndr->flags = _flags_save_string;
1433                 }
1434                 {
1435                         uint32_t _flags_save_string = ndr->flags;
1436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1437                         if (r->comment) {
1438                                 uint32_t _relative_save_offset;
1439                                 _relative_save_offset = ndr->offset;
1440                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1441                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1442                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1443                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1444                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1445                                 if (ndr->offset > ndr->relative_highest_offset) {
1446                                         ndr->relative_highest_offset = ndr->offset;
1447                                 }
1448                                 ndr->offset = _relative_save_offset;
1449                         }
1450                         ndr->flags = _flags_save_string;
1451                 }
1452         }
1453         return NDR_ERR_SUCCESS;
1454 }
1455
1456 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1457 {
1458         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1459         ndr->depth++;
1460         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1461         ndr_print_ptr(ndr, "description", r->description);
1462         ndr->depth++;
1463         if (r->description) {
1464                 ndr_print_string(ndr, "description", r->description);
1465         }
1466         ndr->depth--;
1467         ndr_print_ptr(ndr, "name", r->name);
1468         ndr->depth++;
1469         if (r->name) {
1470                 ndr_print_string(ndr, "name", r->name);
1471         }
1472         ndr->depth--;
1473         ndr_print_ptr(ndr, "comment", r->comment);
1474         ndr->depth++;
1475         if (r->comment) {
1476                 ndr_print_string(ndr, "comment", r->comment);
1477         }
1478         ndr->depth--;
1479         ndr->depth--;
1480 }
1481
1482 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1483 {
1484         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1485 }
1486
1487 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1488 {
1489         uint32_t _ptr_servername;
1490         TALLOC_CTX *_mem_save_servername_0;
1491         uint32_t _ptr_printername;
1492         TALLOC_CTX *_mem_save_printername_0;
1493         uint32_t _ptr_sharename;
1494         TALLOC_CTX *_mem_save_sharename_0;
1495         uint32_t _ptr_portname;
1496         TALLOC_CTX *_mem_save_portname_0;
1497         uint32_t _ptr_drivername;
1498         TALLOC_CTX *_mem_save_drivername_0;
1499         uint32_t _ptr_comment;
1500         TALLOC_CTX *_mem_save_comment_0;
1501         uint32_t _ptr_location;
1502         TALLOC_CTX *_mem_save_location_0;
1503         uint32_t _ptr_devmode;
1504         TALLOC_CTX *_mem_save_devmode_0;
1505         uint32_t _ptr_sepfile;
1506         TALLOC_CTX *_mem_save_sepfile_0;
1507         uint32_t _ptr_printprocessor;
1508         TALLOC_CTX *_mem_save_printprocessor_0;
1509         uint32_t _ptr_datatype;
1510         TALLOC_CTX *_mem_save_datatype_0;
1511         uint32_t _ptr_parameters;
1512         TALLOC_CTX *_mem_save_parameters_0;
1513         uint32_t _ptr_secdesc;
1514         TALLOC_CTX *_mem_save_secdesc_0;
1515         if (ndr_flags & NDR_SCALARS) {
1516                 NDR_CHECK(ndr_pull_align(ndr, 5));
1517                 {
1518                         uint32_t _flags_save_string = ndr->flags;
1519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1520                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1521                         if (_ptr_servername) {
1522                                 NDR_PULL_ALLOC(ndr, r->servername);
1523                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1524                         } else {
1525                                 r->servername = NULL;
1526                         }
1527                         ndr->flags = _flags_save_string;
1528                 }
1529                 {
1530                         uint32_t _flags_save_string = ndr->flags;
1531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1532                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1533                         if (_ptr_printername) {
1534                                 NDR_PULL_ALLOC(ndr, r->printername);
1535                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1536                         } else {
1537                                 r->printername = NULL;
1538                         }
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_pull_generic_ptr(ndr, &_ptr_sharename));
1545                         if (_ptr_sharename) {
1546                                 NDR_PULL_ALLOC(ndr, r->sharename);
1547                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1548                         } else {
1549                                 r->sharename = NULL;
1550                         }
1551                         ndr->flags = _flags_save_string;
1552                 }
1553                 {
1554                         uint32_t _flags_save_string = ndr->flags;
1555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1556                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1557                         if (_ptr_portname) {
1558                                 NDR_PULL_ALLOC(ndr, r->portname);
1559                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1560                         } else {
1561                                 r->portname = NULL;
1562                         }
1563                         ndr->flags = _flags_save_string;
1564                 }
1565                 {
1566                         uint32_t _flags_save_string = ndr->flags;
1567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1568                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1569                         if (_ptr_drivername) {
1570                                 NDR_PULL_ALLOC(ndr, r->drivername);
1571                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1572                         } else {
1573                                 r->drivername = NULL;
1574                         }
1575                         ndr->flags = _flags_save_string;
1576                 }
1577                 {
1578                         uint32_t _flags_save_string = ndr->flags;
1579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1580                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1581                         if (_ptr_comment) {
1582                                 NDR_PULL_ALLOC(ndr, r->comment);
1583                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1584                         } else {
1585                                 r->comment = NULL;
1586                         }
1587                         ndr->flags = _flags_save_string;
1588                 }
1589                 {
1590                         uint32_t _flags_save_string = ndr->flags;
1591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1592                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1593                         if (_ptr_location) {
1594                                 NDR_PULL_ALLOC(ndr, r->location);
1595                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1596                         } else {
1597                                 r->location = NULL;
1598                         }
1599                         ndr->flags = _flags_save_string;
1600                 }
1601                 {
1602                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1604                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1605                         if (_ptr_devmode) {
1606                                 NDR_PULL_ALLOC(ndr, r->devmode);
1607                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1608                         } else {
1609                                 r->devmode = NULL;
1610                         }
1611                         ndr->flags = _flags_save_spoolss_DeviceMode;
1612                 }
1613                 {
1614                         uint32_t _flags_save_string = ndr->flags;
1615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1616                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1617                         if (_ptr_sepfile) {
1618                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1619                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1620                         } else {
1621                                 r->sepfile = NULL;
1622                         }
1623                         ndr->flags = _flags_save_string;
1624                 }
1625                 {
1626                         uint32_t _flags_save_string = ndr->flags;
1627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1628                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1629                         if (_ptr_printprocessor) {
1630                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1631                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1632                         } else {
1633                                 r->printprocessor = NULL;
1634                         }
1635                         ndr->flags = _flags_save_string;
1636                 }
1637                 {
1638                         uint32_t _flags_save_string = ndr->flags;
1639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1640                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1641                         if (_ptr_datatype) {
1642                                 NDR_PULL_ALLOC(ndr, r->datatype);
1643                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1644                         } else {
1645                                 r->datatype = NULL;
1646                         }
1647                         ndr->flags = _flags_save_string;
1648                 }
1649                 {
1650                         uint32_t _flags_save_string = ndr->flags;
1651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1652                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1653                         if (_ptr_parameters) {
1654                                 NDR_PULL_ALLOC(ndr, r->parameters);
1655                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1656                         } else {
1657                                 r->parameters = NULL;
1658                         }
1659                         ndr->flags = _flags_save_string;
1660                 }
1661                 {
1662                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1665                         if (_ptr_secdesc) {
1666                                 NDR_PULL_ALLOC(ndr, r->secdesc);
1667                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1668                         } else {
1669                                 r->secdesc = NULL;
1670                         }
1671                         ndr->flags = _flags_save_spoolss_security_descriptor;
1672                 }
1673                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1675                 if (r->priority > 99) {
1676                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1677                 }
1678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1681                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1684                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1685         }
1686         if (ndr_flags & NDR_BUFFERS) {
1687                 {
1688                         uint32_t _flags_save_string = ndr->flags;
1689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1690                         if (r->servername) {
1691                                 uint32_t _relative_save_offset;
1692                                 _relative_save_offset = ndr->offset;
1693                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1694                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1695                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1696                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1697                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1698                                 if (ndr->offset > ndr->relative_highest_offset) {
1699                                         ndr->relative_highest_offset = ndr->offset;
1700                                 }
1701                                 ndr->offset = _relative_save_offset;
1702                         }
1703                         ndr->flags = _flags_save_string;
1704                 }
1705                 {
1706                         uint32_t _flags_save_string = ndr->flags;
1707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1708                         if (r->printername) {
1709                                 uint32_t _relative_save_offset;
1710                                 _relative_save_offset = ndr->offset;
1711                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1712                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1713                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1714                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1715                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1716                                 if (ndr->offset > ndr->relative_highest_offset) {
1717                                         ndr->relative_highest_offset = ndr->offset;
1718                                 }
1719                                 ndr->offset = _relative_save_offset;
1720                         }
1721                         ndr->flags = _flags_save_string;
1722                 }
1723                 {
1724                         uint32_t _flags_save_string = ndr->flags;
1725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1726                         if (r->sharename) {
1727                                 uint32_t _relative_save_offset;
1728                                 _relative_save_offset = ndr->offset;
1729                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1730                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1731                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1732                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1733                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1734                                 if (ndr->offset > ndr->relative_highest_offset) {
1735                                         ndr->relative_highest_offset = ndr->offset;
1736                                 }
1737                                 ndr->offset = _relative_save_offset;
1738                         }
1739                         ndr->flags = _flags_save_string;
1740                 }
1741                 {
1742                         uint32_t _flags_save_string = ndr->flags;
1743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1744                         if (r->portname) {
1745                                 uint32_t _relative_save_offset;
1746                                 _relative_save_offset = ndr->offset;
1747                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1748                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1749                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1750                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1751                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1752                                 if (ndr->offset > ndr->relative_highest_offset) {
1753                                         ndr->relative_highest_offset = ndr->offset;
1754                                 }
1755                                 ndr->offset = _relative_save_offset;
1756                         }
1757                         ndr->flags = _flags_save_string;
1758                 }
1759                 {
1760                         uint32_t _flags_save_string = ndr->flags;
1761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1762                         if (r->drivername) {
1763                                 uint32_t _relative_save_offset;
1764                                 _relative_save_offset = ndr->offset;
1765                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1766                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1767                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1768                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1769                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1770                                 if (ndr->offset > ndr->relative_highest_offset) {
1771                                         ndr->relative_highest_offset = ndr->offset;
1772                                 }
1773                                 ndr->offset = _relative_save_offset;
1774                         }
1775                         ndr->flags = _flags_save_string;
1776                 }
1777                 {
1778                         uint32_t _flags_save_string = ndr->flags;
1779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1780                         if (r->comment) {
1781                                 uint32_t _relative_save_offset;
1782                                 _relative_save_offset = ndr->offset;
1783                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1784                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1785                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1786                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1787                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1788                                 if (ndr->offset > ndr->relative_highest_offset) {
1789                                         ndr->relative_highest_offset = ndr->offset;
1790                                 }
1791                                 ndr->offset = _relative_save_offset;
1792                         }
1793                         ndr->flags = _flags_save_string;
1794                 }
1795                 {
1796                         uint32_t _flags_save_string = ndr->flags;
1797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1798                         if (r->location) {
1799                                 uint32_t _relative_save_offset;
1800                                 _relative_save_offset = ndr->offset;
1801                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1802                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1803                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1804                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1805                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1806                                 if (ndr->offset > ndr->relative_highest_offset) {
1807                                         ndr->relative_highest_offset = ndr->offset;
1808                                 }
1809                                 ndr->offset = _relative_save_offset;
1810                         }
1811                         ndr->flags = _flags_save_string;
1812                 }
1813                 {
1814                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1816                         if (r->devmode) {
1817                                 uint32_t _relative_save_offset;
1818                                 _relative_save_offset = ndr->offset;
1819                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1820                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1821                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1822                                 {
1823                                         struct ndr_pull *_ndr_devmode;
1824                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1825                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1826                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1827                                 }
1828                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1829                                 if (ndr->offset > ndr->relative_highest_offset) {
1830                                         ndr->relative_highest_offset = ndr->offset;
1831                                 }
1832                                 ndr->offset = _relative_save_offset;
1833                         }
1834                         ndr->flags = _flags_save_spoolss_DeviceMode;
1835                 }
1836                 {
1837                         uint32_t _flags_save_string = ndr->flags;
1838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1839                         if (r->sepfile) {
1840                                 uint32_t _relative_save_offset;
1841                                 _relative_save_offset = ndr->offset;
1842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1843                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1844                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1847                                 if (ndr->offset > ndr->relative_highest_offset) {
1848                                         ndr->relative_highest_offset = ndr->offset;
1849                                 }
1850                                 ndr->offset = _relative_save_offset;
1851                         }
1852                         ndr->flags = _flags_save_string;
1853                 }
1854                 {
1855                         uint32_t _flags_save_string = ndr->flags;
1856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1857                         if (r->printprocessor) {
1858                                 uint32_t _relative_save_offset;
1859                                 _relative_save_offset = ndr->offset;
1860                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1861                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1862                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1863                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1864                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1865                                 if (ndr->offset > ndr->relative_highest_offset) {
1866                                         ndr->relative_highest_offset = ndr->offset;
1867                                 }
1868                                 ndr->offset = _relative_save_offset;
1869                         }
1870                         ndr->flags = _flags_save_string;
1871                 }
1872                 {
1873                         uint32_t _flags_save_string = ndr->flags;
1874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1875                         if (r->datatype) {
1876                                 uint32_t _relative_save_offset;
1877                                 _relative_save_offset = ndr->offset;
1878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1879                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1880                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1883                                 if (ndr->offset > ndr->relative_highest_offset) {
1884                                         ndr->relative_highest_offset = ndr->offset;
1885                                 }
1886                                 ndr->offset = _relative_save_offset;
1887                         }
1888                         ndr->flags = _flags_save_string;
1889                 }
1890                 {
1891                         uint32_t _flags_save_string = ndr->flags;
1892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1893                         if (r->parameters) {
1894                                 uint32_t _relative_save_offset;
1895                                 _relative_save_offset = ndr->offset;
1896                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1897                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1898                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1899                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1900                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1901                                 if (ndr->offset > ndr->relative_highest_offset) {
1902                                         ndr->relative_highest_offset = ndr->offset;
1903                                 }
1904                                 ndr->offset = _relative_save_offset;
1905                         }
1906                         ndr->flags = _flags_save_string;
1907                 }
1908                 {
1909                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1911                         if (r->secdesc) {
1912                                 uint32_t _relative_save_offset;
1913                                 _relative_save_offset = ndr->offset;
1914                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1915                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1916                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1917                                 {
1918                                         struct ndr_pull *_ndr_secdesc;
1919                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1920                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1921                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1922                                 }
1923                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1924                                 if (ndr->offset > ndr->relative_highest_offset) {
1925                                         ndr->relative_highest_offset = ndr->offset;
1926                                 }
1927                                 ndr->offset = _relative_save_offset;
1928                         }
1929                         ndr->flags = _flags_save_spoolss_security_descriptor;
1930                 }
1931         }
1932         return NDR_ERR_SUCCESS;
1933 }
1934
1935 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1936 {
1937         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1938         ndr->depth++;
1939         ndr_print_ptr(ndr, "servername", r->servername);
1940         ndr->depth++;
1941         if (r->servername) {
1942                 ndr_print_string(ndr, "servername", r->servername);
1943         }
1944         ndr->depth--;
1945         ndr_print_ptr(ndr, "printername", r->printername);
1946         ndr->depth++;
1947         if (r->printername) {
1948                 ndr_print_string(ndr, "printername", r->printername);
1949         }
1950         ndr->depth--;
1951         ndr_print_ptr(ndr, "sharename", r->sharename);
1952         ndr->depth++;
1953         if (r->sharename) {
1954                 ndr_print_string(ndr, "sharename", r->sharename);
1955         }
1956         ndr->depth--;
1957         ndr_print_ptr(ndr, "portname", r->portname);
1958         ndr->depth++;
1959         if (r->portname) {
1960                 ndr_print_string(ndr, "portname", r->portname);
1961         }
1962         ndr->depth--;
1963         ndr_print_ptr(ndr, "drivername", r->drivername);
1964         ndr->depth++;
1965         if (r->drivername) {
1966                 ndr_print_string(ndr, "drivername", r->drivername);
1967         }
1968         ndr->depth--;
1969         ndr_print_ptr(ndr, "comment", r->comment);
1970         ndr->depth++;
1971         if (r->comment) {
1972                 ndr_print_string(ndr, "comment", r->comment);
1973         }
1974         ndr->depth--;
1975         ndr_print_ptr(ndr, "location", r->location);
1976         ndr->depth++;
1977         if (r->location) {
1978                 ndr_print_string(ndr, "location", r->location);
1979         }
1980         ndr->depth--;
1981         ndr_print_ptr(ndr, "devmode", r->devmode);
1982         ndr->depth++;
1983         if (r->devmode) {
1984                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1985         }
1986         ndr->depth--;
1987         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1988         ndr->depth++;
1989         if (r->sepfile) {
1990                 ndr_print_string(ndr, "sepfile", r->sepfile);
1991         }
1992         ndr->depth--;
1993         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1994         ndr->depth++;
1995         if (r->printprocessor) {
1996                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1997         }
1998         ndr->depth--;
1999         ndr_print_ptr(ndr, "datatype", r->datatype);
2000         ndr->depth++;
2001         if (r->datatype) {
2002                 ndr_print_string(ndr, "datatype", r->datatype);
2003         }
2004         ndr->depth--;
2005         ndr_print_ptr(ndr, "parameters", r->parameters);
2006         ndr->depth++;
2007         if (r->parameters) {
2008                 ndr_print_string(ndr, "parameters", r->parameters);
2009         }
2010         ndr->depth--;
2011         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2012         ndr->depth++;
2013         if (r->secdesc) {
2014                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2015         }
2016         ndr->depth--;
2017         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2018         ndr_print_uint32(ndr, "priority", r->priority);
2019         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2020         ndr_print_uint32(ndr, "starttime", r->starttime);
2021         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2022         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2023         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2024         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2025         ndr->depth--;
2026 }
2027
2028 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2029 {
2030         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2031 }
2032
2033 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2034 {
2035         if (ndr_flags & NDR_SCALARS) {
2036                 NDR_CHECK(ndr_push_align(ndr, 5));
2037                 {
2038                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2040                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2041                         ndr->flags = _flags_save_spoolss_security_descriptor;
2042                 }
2043                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2044         }
2045         if (ndr_flags & NDR_BUFFERS) {
2046                 {
2047                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2049                         if (r->secdesc) {
2050                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
2051                                 {
2052                                         struct ndr_push *_ndr_secdesc;
2053                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2054                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2055                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2056                                 }
2057                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
2058                         }
2059                         ndr->flags = _flags_save_spoolss_security_descriptor;
2060                 }
2061         }
2062         return NDR_ERR_SUCCESS;
2063 }
2064
2065 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2066 {
2067         uint32_t _ptr_secdesc;
2068         TALLOC_CTX *_mem_save_secdesc_0;
2069         if (ndr_flags & NDR_SCALARS) {
2070                 NDR_CHECK(ndr_pull_align(ndr, 5));
2071                 {
2072                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2074                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2075                         if (_ptr_secdesc) {
2076                                 NDR_PULL_ALLOC(ndr, r->secdesc);
2077                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2078                         } else {
2079                                 r->secdesc = NULL;
2080                         }
2081                         ndr->flags = _flags_save_spoolss_security_descriptor;
2082                 }
2083                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2084         }
2085         if (ndr_flags & NDR_BUFFERS) {
2086                 {
2087                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2089                         if (r->secdesc) {
2090                                 uint32_t _relative_save_offset;
2091                                 _relative_save_offset = ndr->offset;
2092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2093                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2094                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2095                                 {
2096                                         struct ndr_pull *_ndr_secdesc;
2097                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2098                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2099                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2100                                 }
2101                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2102                                 if (ndr->offset > ndr->relative_highest_offset) {
2103                                         ndr->relative_highest_offset = ndr->offset;
2104                                 }
2105                                 ndr->offset = _relative_save_offset;
2106                         }
2107                         ndr->flags = _flags_save_spoolss_security_descriptor;
2108                 }
2109         }
2110         return NDR_ERR_SUCCESS;
2111 }
2112
2113 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2114 {
2115         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2116         ndr->depth++;
2117         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2118         ndr->depth++;
2119         if (r->secdesc) {
2120                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2121         }
2122         ndr->depth--;
2123         ndr->depth--;
2124 }
2125
2126 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2127 {
2128         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2129 }
2130
2131 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2132 {
2133         if (ndr_flags & NDR_SCALARS) {
2134                 NDR_CHECK(ndr_push_align(ndr, 5));
2135                 {
2136                         uint32_t _flags_save_string = ndr->flags;
2137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2138                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2139                         ndr->flags = _flags_save_string;
2140                 }
2141                 {
2142                         uint32_t _flags_save_string = ndr->flags;
2143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2144                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2145                         ndr->flags = _flags_save_string;
2146                 }
2147                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2148                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2149         }
2150         if (ndr_flags & NDR_BUFFERS) {
2151                 {
2152                         uint32_t _flags_save_string = ndr->flags;
2153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2154                         if (r->printername) {
2155                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2156                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2157                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2158                         }
2159                         ndr->flags = _flags_save_string;
2160                 }
2161                 {
2162                         uint32_t _flags_save_string = ndr->flags;
2163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2164                         if (r->servername) {
2165                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
2166                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2167                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
2168                         }
2169                         ndr->flags = _flags_save_string;
2170                 }
2171         }
2172         return NDR_ERR_SUCCESS;
2173 }
2174
2175 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2176 {
2177         uint32_t _ptr_printername;
2178         TALLOC_CTX *_mem_save_printername_0;
2179         uint32_t _ptr_servername;
2180         TALLOC_CTX *_mem_save_servername_0;
2181         if (ndr_flags & NDR_SCALARS) {
2182                 NDR_CHECK(ndr_pull_align(ndr, 5));
2183                 {
2184                         uint32_t _flags_save_string = ndr->flags;
2185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2186                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2187                         if (_ptr_printername) {
2188                                 NDR_PULL_ALLOC(ndr, r->printername);
2189                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2190                         } else {
2191                                 r->printername = NULL;
2192                         }
2193                         ndr->flags = _flags_save_string;
2194                 }
2195                 {
2196                         uint32_t _flags_save_string = ndr->flags;
2197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2198                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2199                         if (_ptr_servername) {
2200                                 NDR_PULL_ALLOC(ndr, r->servername);
2201                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2202                         } else {
2203                                 r->servername = NULL;
2204                         }
2205                         ndr->flags = _flags_save_string;
2206                 }
2207                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2208                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2209         }
2210         if (ndr_flags & NDR_BUFFERS) {
2211                 {
2212                         uint32_t _flags_save_string = ndr->flags;
2213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2214                         if (r->printername) {
2215                                 uint32_t _relative_save_offset;
2216                                 _relative_save_offset = ndr->offset;
2217                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2218                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2219                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2220                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2221                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2222                                 if (ndr->offset > ndr->relative_highest_offset) {
2223                                         ndr->relative_highest_offset = ndr->offset;
2224                                 }
2225                                 ndr->offset = _relative_save_offset;
2226                         }
2227                         ndr->flags = _flags_save_string;
2228                 }
2229                 {
2230                         uint32_t _flags_save_string = ndr->flags;
2231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2232                         if (r->servername) {
2233                                 uint32_t _relative_save_offset;
2234                                 _relative_save_offset = ndr->offset;
2235                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2236                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2237                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2238                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2239                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2240                                 if (ndr->offset > ndr->relative_highest_offset) {
2241                                         ndr->relative_highest_offset = ndr->offset;
2242                                 }
2243                                 ndr->offset = _relative_save_offset;
2244                         }
2245                         ndr->flags = _flags_save_string;
2246                 }
2247         }
2248         return NDR_ERR_SUCCESS;
2249 }
2250
2251 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2252 {
2253         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2254         ndr->depth++;
2255         ndr_print_ptr(ndr, "printername", r->printername);
2256         ndr->depth++;
2257         if (r->printername) {
2258                 ndr_print_string(ndr, "printername", r->printername);
2259         }
2260         ndr->depth--;
2261         ndr_print_ptr(ndr, "servername", r->servername);
2262         ndr->depth++;
2263         if (r->servername) {
2264                 ndr_print_string(ndr, "servername", r->servername);
2265         }
2266         ndr->depth--;
2267         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2268         ndr->depth--;
2269 }
2270
2271 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2272 {
2273         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2274 }
2275
2276 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2277 {
2278         if (ndr_flags & NDR_SCALARS) {
2279                 NDR_CHECK(ndr_push_align(ndr, 5));
2280                 {
2281                         uint32_t _flags_save_string = ndr->flags;
2282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2283                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2284                         ndr->flags = _flags_save_string;
2285                 }
2286                 {
2287                         uint32_t _flags_save_string = ndr->flags;
2288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2289                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2290                         ndr->flags = _flags_save_string;
2291                 }
2292                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2295                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2296         }
2297         if (ndr_flags & NDR_BUFFERS) {
2298                 {
2299                         uint32_t _flags_save_string = ndr->flags;
2300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2301                         if (r->printername) {
2302                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2303                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2304                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2305                         }
2306                         ndr->flags = _flags_save_string;
2307                 }
2308                 {
2309                         uint32_t _flags_save_string = ndr->flags;
2310                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2311                         if (r->portname) {
2312                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
2313                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2314                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
2315                         }
2316                         ndr->flags = _flags_save_string;
2317                 }
2318         }
2319         return NDR_ERR_SUCCESS;
2320 }
2321
2322 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2323 {
2324         uint32_t _ptr_printername;
2325         TALLOC_CTX *_mem_save_printername_0;
2326         uint32_t _ptr_portname;
2327         TALLOC_CTX *_mem_save_portname_0;
2328         if (ndr_flags & NDR_SCALARS) {
2329                 NDR_CHECK(ndr_pull_align(ndr, 5));
2330                 {
2331                         uint32_t _flags_save_string = ndr->flags;
2332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2333                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2334                         if (_ptr_printername) {
2335                                 NDR_PULL_ALLOC(ndr, r->printername);
2336                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2337                         } else {
2338                                 r->printername = NULL;
2339                         }
2340                         ndr->flags = _flags_save_string;
2341                 }
2342                 {
2343                         uint32_t _flags_save_string = ndr->flags;
2344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2345                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2346                         if (_ptr_portname) {
2347                                 NDR_PULL_ALLOC(ndr, r->portname);
2348                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2349                         } else {
2350                                 r->portname = NULL;
2351                         }
2352                         ndr->flags = _flags_save_string;
2353                 }
2354                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2357                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2358         }
2359         if (ndr_flags & NDR_BUFFERS) {
2360                 {
2361                         uint32_t _flags_save_string = ndr->flags;
2362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2363                         if (r->printername) {
2364                                 uint32_t _relative_save_offset;
2365                                 _relative_save_offset = ndr->offset;
2366                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2367                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2368                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2369                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2370                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2371                                 if (ndr->offset > ndr->relative_highest_offset) {
2372                                         ndr->relative_highest_offset = ndr->offset;
2373                                 }
2374                                 ndr->offset = _relative_save_offset;
2375                         }
2376                         ndr->flags = _flags_save_string;
2377                 }
2378                 {
2379                         uint32_t _flags_save_string = ndr->flags;
2380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2381                         if (r->portname) {
2382                                 uint32_t _relative_save_offset;
2383                                 _relative_save_offset = ndr->offset;
2384                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2385                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2386                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2387                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2388                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2389                                 if (ndr->offset > ndr->relative_highest_offset) {
2390                                         ndr->relative_highest_offset = ndr->offset;
2391                                 }
2392                                 ndr->offset = _relative_save_offset;
2393                         }
2394                         ndr->flags = _flags_save_string;
2395                 }
2396         }
2397         return NDR_ERR_SUCCESS;
2398 }
2399
2400 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2401 {
2402         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2403         ndr->depth++;
2404         ndr_print_ptr(ndr, "printername", r->printername);
2405         ndr->depth++;
2406         if (r->printername) {
2407                 ndr_print_string(ndr, "printername", r->printername);
2408         }
2409         ndr->depth--;
2410         ndr_print_ptr(ndr, "portname", r->portname);
2411         ndr->depth++;
2412         if (r->portname) {
2413                 ndr_print_string(ndr, "portname", r->portname);
2414         }
2415         ndr->depth--;
2416         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2417         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2418         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2419         ndr->depth--;
2420 }
2421
2422 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2423 {
2424         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2425 }
2426
2427 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2428 {
2429         if (ndr_flags & NDR_SCALARS) {
2430                 NDR_CHECK(ndr_push_align(ndr, 4));
2431                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2432                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2433         }
2434         if (ndr_flags & NDR_BUFFERS) {
2435         }
2436         return NDR_ERR_SUCCESS;
2437 }
2438
2439 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2440 {
2441         if (ndr_flags & NDR_SCALARS) {
2442                 NDR_CHECK(ndr_pull_align(ndr, 4));
2443                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2444                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2445         }
2446         if (ndr_flags & NDR_BUFFERS) {
2447         }
2448         return NDR_ERR_SUCCESS;
2449 }
2450
2451 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2452 {
2453         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2454         ndr->depth++;
2455         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2456         ndr->depth--;
2457 }
2458
2459 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2460 {
2461         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2462 }
2463
2464 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2465 {
2466         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2467         return NDR_ERR_SUCCESS;
2468 }
2469
2470 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2471 {
2472         uint32_t v;
2473         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2474         *r = v;
2475         return NDR_ERR_SUCCESS;
2476 }
2477
2478 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2479 {
2480         ndr_print_uint32(ndr, name, r);
2481         ndr->depth++;
2482         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2483         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2484         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2485         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2486         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2487         ndr->depth--;
2488 }
2489
2490 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2491 {
2492         if (ndr_flags & NDR_SCALARS) {
2493                 NDR_CHECK(ndr_push_align(ndr, 5));
2494                 {
2495                         uint32_t _flags_save_string = ndr->flags;
2496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2497                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2498                         ndr->flags = _flags_save_string;
2499                 }
2500                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2501                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2502         }
2503         if (ndr_flags & NDR_BUFFERS) {
2504                 {
2505                         uint32_t _flags_save_string = ndr->flags;
2506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2507                         if (r->guid) {
2508                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->guid));
2509                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2510                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->guid));
2511                         }
2512                         ndr->flags = _flags_save_string;
2513                 }
2514         }
2515         return NDR_ERR_SUCCESS;
2516 }
2517
2518 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2519 {
2520         uint32_t _ptr_guid;
2521         TALLOC_CTX *_mem_save_guid_0;
2522         if (ndr_flags & NDR_SCALARS) {
2523                 NDR_CHECK(ndr_pull_align(ndr, 5));
2524                 {
2525                         uint32_t _flags_save_string = ndr->flags;
2526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2527                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2528                         if (_ptr_guid) {
2529                                 NDR_PULL_ALLOC(ndr, r->guid);
2530                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2531                         } else {
2532                                 r->guid = NULL;
2533                         }
2534                         ndr->flags = _flags_save_string;
2535                 }
2536                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2538         }
2539         if (ndr_flags & NDR_BUFFERS) {
2540                 {
2541                         uint32_t _flags_save_string = ndr->flags;
2542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2543                         if (r->guid) {
2544                                 uint32_t _relative_save_offset;
2545                                 _relative_save_offset = ndr->offset;
2546                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2547                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2548                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2549                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2550                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2551                                 if (ndr->offset > ndr->relative_highest_offset) {
2552                                         ndr->relative_highest_offset = ndr->offset;
2553                                 }
2554                                 ndr->offset = _relative_save_offset;
2555                         }
2556                         ndr->flags = _flags_save_string;
2557                 }
2558         }
2559         return NDR_ERR_SUCCESS;
2560 }
2561
2562 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2563 {
2564         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2565         ndr->depth++;
2566         ndr_print_ptr(ndr, "guid", r->guid);
2567         ndr->depth++;
2568         if (r->guid) {
2569                 ndr_print_string(ndr, "guid", r->guid);
2570         }
2571         ndr->depth--;
2572         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2573         ndr->depth--;
2574 }
2575
2576 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2577 {
2578         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2579 }
2580
2581 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2582 {
2583         if (ndr_flags & NDR_SCALARS) {
2584                 NDR_CHECK(ndr_push_align(ndr, 5));
2585                 {
2586                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2588                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2589                         ndr->flags = _flags_save_spoolss_DeviceMode;
2590                 }
2591                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2592         }
2593         if (ndr_flags & NDR_BUFFERS) {
2594                 {
2595                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2597                         if (r->devmode) {
2598                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
2599                                 {
2600                                         struct ndr_push *_ndr_devmode;
2601                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2602                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2603                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2604                                 }
2605                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
2606                         }
2607                         ndr->flags = _flags_save_spoolss_DeviceMode;
2608                 }
2609         }
2610         return NDR_ERR_SUCCESS;
2611 }
2612
2613 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2614 {
2615         uint32_t _ptr_devmode;
2616         TALLOC_CTX *_mem_save_devmode_0;
2617         if (ndr_flags & NDR_SCALARS) {
2618                 NDR_CHECK(ndr_pull_align(ndr, 5));
2619                 {
2620                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2622                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2623                         if (_ptr_devmode) {
2624                                 NDR_PULL_ALLOC(ndr, r->devmode);
2625                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2626                         } else {
2627                                 r->devmode = NULL;
2628                         }
2629                         ndr->flags = _flags_save_spoolss_DeviceMode;
2630                 }
2631                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2632         }
2633         if (ndr_flags & NDR_BUFFERS) {
2634                 {
2635                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2637                         if (r->devmode) {
2638                                 uint32_t _relative_save_offset;
2639                                 _relative_save_offset = ndr->offset;
2640                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2641                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2642                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2643                                 {
2644                                         struct ndr_pull *_ndr_devmode;
2645                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2646                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2647                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2648                                 }
2649                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2650                                 if (ndr->offset > ndr->relative_highest_offset) {
2651                                         ndr->relative_highest_offset = ndr->offset;
2652                                 }
2653                                 ndr->offset = _relative_save_offset;
2654                         }
2655                         ndr->flags = _flags_save_spoolss_DeviceMode;
2656                 }
2657         }
2658         return NDR_ERR_SUCCESS;
2659 }
2660
2661 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2662 {
2663         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2664         ndr->depth++;
2665         ndr_print_ptr(ndr, "devmode", r->devmode);
2666         ndr->depth++;
2667         if (r->devmode) {
2668                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2669         }
2670         ndr->depth--;
2671         ndr->depth--;
2672 }
2673
2674 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2675 {
2676         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2677         {
2678                 uint32_t _flags_save_UNION = ndr->flags;
2679                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2680                 if (ndr_flags & NDR_SCALARS) {
2681                         int level = ndr_push_get_switch_value(ndr, r);
2682                         NDR_CHECK(ndr_push_union_align(ndr, 5));
2683                         switch (level) {
2684                                 case 0: {
2685                                         NDR_CHECK(ndr_push_align(ndr, 5));
2686                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2687                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2688                                 break; }
2689
2690                                 case 1: {
2691                                         NDR_CHECK(ndr_push_align(ndr, 5));
2692                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2693                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2694                                 break; }
2695
2696                                 case 2: {
2697                                         NDR_CHECK(ndr_push_align(ndr, 5));
2698                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2699                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2700                                 break; }
2701
2702                                 case 3: {
2703                                         NDR_CHECK(ndr_push_align(ndr, 5));
2704                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2705                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2706                                 break; }
2707
2708                                 case 4: {
2709                                         NDR_CHECK(ndr_push_align(ndr, 5));
2710                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2711                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2712                                 break; }
2713
2714                                 case 5: {
2715                                         NDR_CHECK(ndr_push_align(ndr, 5));
2716                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2717                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2718                                 break; }
2719
2720                                 case 6: {
2721                                         NDR_CHECK(ndr_push_align(ndr, 4));
2722                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2723                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2724                                 break; }
2725
2726                                 case 7: {
2727                                         NDR_CHECK(ndr_push_align(ndr, 5));
2728                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2729                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2730                                 break; }
2731
2732                                 case 8: {
2733                                         NDR_CHECK(ndr_push_align(ndr, 5));
2734                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2735                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2736                                 break; }
2737
2738                                 case 9: {
2739                                         NDR_CHECK(ndr_push_align(ndr, 5));
2740                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2741                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2742                                 break; }
2743
2744                                 default: {
2745                                 break; }
2746
2747                         }
2748                 }
2749                 if (ndr_flags & NDR_BUFFERS) {
2750                         int level = ndr_push_get_switch_value(ndr, r);
2751                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2752                         switch (level) {
2753                                 case 0:
2754                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2755                                 break;
2756
2757                                 case 1:
2758                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2759                                 break;
2760
2761                                 case 2:
2762                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2763                                 break;
2764
2765                                 case 3:
2766                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2767                                 break;
2768
2769                                 case 4:
2770                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2771                                 break;
2772
2773                                 case 5:
2774                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2775                                 break;
2776
2777                                 case 6:
2778                                 break;
2779
2780                                 case 7:
2781                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2782                                 break;
2783
2784                                 case 8:
2785                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2786                                 break;
2787
2788                                 case 9:
2789                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2790                                 break;
2791
2792                                 default:
2793                                 break;
2794
2795                         }
2796                 }
2797                 ndr->flags = _flags_save_UNION;
2798         }
2799         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2800         return NDR_ERR_SUCCESS;
2801 }
2802
2803 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2804 {
2805         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2806         int level;
2807         {
2808                 uint32_t _flags_save_UNION = ndr->flags;
2809                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2810                 level = ndr_pull_get_switch_value(ndr, r);
2811                 if (ndr_flags & NDR_SCALARS) {
2812                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
2813                         switch (level) {
2814                                 case 0: {
2815                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2816                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2817                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2818                                 break; }
2819
2820                                 case 1: {
2821                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2822                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2823                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2824                                 break; }
2825
2826                                 case 2: {
2827                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2828                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2829                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2830                                 break; }
2831
2832                                 case 3: {
2833                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2834                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2835                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2836                                 break; }
2837
2838                                 case 4: {
2839                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2840                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2841                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2842                                 break; }
2843
2844                                 case 5: {
2845                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2846                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2847                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2848                                 break; }
2849
2850                                 case 6: {
2851                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2852                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2853                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2854                                 break; }
2855
2856                                 case 7: {
2857                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2858                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2859                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2860                                 break; }
2861
2862                                 case 8: {
2863                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2864                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2865                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2866                                 break; }
2867
2868                                 case 9: {
2869                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2870                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2871                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2872                                 break; }
2873
2874                                 default: {
2875                                 break; }
2876
2877                         }
2878                 }
2879                 if (ndr_flags & NDR_BUFFERS) {
2880                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2881                         switch (level) {
2882                                 case 0:
2883                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2884                                 break;
2885
2886                                 case 1:
2887                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2888                                 break;
2889
2890                                 case 2:
2891                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2892                                 break;
2893
2894                                 case 3:
2895                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2896                                 break;
2897
2898                                 case 4:
2899                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2900                                 break;
2901
2902                                 case 5:
2903                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2904                                 break;
2905
2906                                 case 6:
2907                                 break;
2908
2909                                 case 7:
2910                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2911                                 break;
2912
2913                                 case 8:
2914                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2915                                 break;
2916
2917                                 case 9:
2918                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2919                                 break;
2920
2921                                 default:
2922                                 break;
2923
2924                         }
2925                 }
2926                 ndr->flags = _flags_save_UNION;
2927         }
2928         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2929         return NDR_ERR_SUCCESS;
2930 }
2931
2932 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2933 {
2934         int level;
2935         {
2936                 uint32_t _flags_save_UNION = ndr->flags;
2937                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2938                 level = ndr_print_get_switch_value(ndr, r);
2939                 ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2940                 switch (level) {
2941                         case 0:
2942                                 ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2943                         break;
2944
2945                         case 1:
2946                                 ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2947                         break;
2948
2949                         case 2:
2950                                 ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2951                         break;
2952
2953                         case 3:
2954                                 ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2955                         break;
2956
2957                         case 4:
2958                                 ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2959                         break;
2960
2961                         case 5:
2962                                 ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2963                         break;
2964
2965                         case 6:
2966                                 ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2967                         break;
2968
2969                         case 7:
2970                                 ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2971                         break;
2972
2973                         case 8:
2974                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2975                         break;
2976
2977                         case 9:
2978                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2979                         break;
2980
2981                         default:
2982                         break;
2983
2984                 }
2985                 ndr->flags = _flags_save_UNION;
2986         }
2987 }
2988
2989 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2990 {
2991         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
2992         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2993 }
2994
2995 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2996 {
2997         if (ndr_flags & NDR_SCALARS) {
2998                 NDR_CHECK(ndr_push_align(ndr, 5));
2999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3001                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3002         }
3003         if (ndr_flags & NDR_BUFFERS) {
3004                 if (r->devmode) {
3005                         {
3006                                 struct ndr_push *_ndr_devmode;
3007                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3008                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3009                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3010                         }
3011                 }
3012         }
3013         return NDR_ERR_SUCCESS;
3014 }
3015
3016 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3017 {
3018         uint32_t _ptr_devmode;
3019         TALLOC_CTX *_mem_save_devmode_0;
3020         if (ndr_flags & NDR_SCALARS) {
3021                 NDR_CHECK(ndr_pull_align(ndr, 5));
3022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3024                 if (_ptr_devmode) {
3025                         NDR_PULL_ALLOC(ndr, r->devmode);
3026                 } else {
3027                         r->devmode = NULL;
3028                 }
3029                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3030         }
3031         if (ndr_flags & NDR_BUFFERS) {
3032                 if (r->devmode) {
3033                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3034                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3035                         {
3036                                 struct ndr_pull *_ndr_devmode;
3037                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3038                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3039                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3040                         }
3041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3042                 }
3043         }
3044         return NDR_ERR_SUCCESS;
3045 }
3046
3047 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3048 {
3049         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3050         ndr->depth++;
3051         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);
3052         ndr_print_ptr(ndr, "devmode", r->devmode);
3053         ndr->depth++;
3054         if (r->devmode) {
3055                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3056         }
3057         ndr->depth--;
3058         ndr->depth--;
3059 }
3060
3061 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3062 {
3063         if (ndr_flags & NDR_SCALARS) {
3064                 NDR_CHECK(ndr_push_align(ndr, 5));
3065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3066                 {
3067                         uint32_t _flags_save_string = ndr->flags;
3068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3069                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3070                         ndr->flags = _flags_save_string;
3071                 }
3072                 {
3073                         uint32_t _flags_save_string = ndr->flags;
3074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3075                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3076                         ndr->flags = _flags_save_string;
3077                 }
3078                 {
3079                         uint32_t _flags_save_string = ndr->flags;
3080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3081                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3082                         ndr->flags = _flags_save_string;
3083                 }
3084                 {
3085                         uint32_t _flags_save_string = ndr->flags;
3086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3087                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3088                         ndr->flags = _flags_save_string;
3089                 }
3090                 {
3091                         uint32_t _flags_save_string = ndr->flags;
3092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3093                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3094                         ndr->flags = _flags_save_string;
3095                 }
3096                 {
3097                         uint32_t _flags_save_string = ndr->flags;
3098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3099                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3100                         ndr->flags = _flags_save_string;
3101                 }
3102                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3107                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3108                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3109         }
3110         if (ndr_flags & NDR_BUFFERS) {
3111                 {
3112                         uint32_t _flags_save_string = ndr->flags;
3113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3114                         if (r->printer_name) {
3115                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3116                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3117                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3118                         }
3119                         ndr->flags = _flags_save_string;
3120                 }
3121                 {
3122                         uint32_t _flags_save_string = ndr->flags;
3123                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3124                         if (r->server_name) {
3125                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3126                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3127                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3128                         }
3129                         ndr->flags = _flags_save_string;
3130                 }
3131                 {
3132                         uint32_t _flags_save_string = ndr->flags;
3133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3134                         if (r->user_name) {
3135                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3136                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3137                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3138                         }
3139                         ndr->flags = _flags_save_string;
3140                 }
3141                 {
3142                         uint32_t _flags_save_string = ndr->flags;
3143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3144                         if (r->document_name) {
3145                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3146                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3147                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3148                         }
3149                         ndr->flags = _flags_save_string;
3150                 }
3151                 {
3152                         uint32_t _flags_save_string = ndr->flags;
3153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3154                         if (r->data_type) {
3155                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3156                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3157                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3158                         }
3159                         ndr->flags = _flags_save_string;
3160                 }
3161                 {
3162                         uint32_t _flags_save_string = ndr->flags;
3163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3164                         if (r->text_status) {
3165                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3166                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3167                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3168                         }
3169                         ndr->flags = _flags_save_string;
3170                 }
3171         }
3172         return NDR_ERR_SUCCESS;
3173 }
3174
3175 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3176 {
3177         uint32_t _ptr_printer_name;
3178         TALLOC_CTX *_mem_save_printer_name_0;
3179         uint32_t _ptr_server_name;
3180         TALLOC_CTX *_mem_save_server_name_0;
3181         uint32_t _ptr_user_name;
3182         TALLOC_CTX *_mem_save_user_name_0;
3183         uint32_t _ptr_document_name;
3184         TALLOC_CTX *_mem_save_document_name_0;
3185         uint32_t _ptr_data_type;
3186         TALLOC_CTX *_mem_save_data_type_0;
3187         uint32_t _ptr_text_status;
3188         TALLOC_CTX *_mem_save_text_status_0;
3189         if (ndr_flags & NDR_SCALARS) {
3190                 NDR_CHECK(ndr_pull_align(ndr, 5));
3191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3192                 {
3193                         uint32_t _flags_save_string = ndr->flags;
3194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3196                         if (_ptr_printer_name) {
3197                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3199                         } else {
3200                                 r->printer_name = NULL;
3201                         }
3202                         ndr->flags = _flags_save_string;
3203                 }
3204                 {
3205                         uint32_t _flags_save_string = ndr->flags;
3206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3207                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3208                         if (_ptr_server_name) {
3209                                 NDR_PULL_ALLOC(ndr, r->server_name);
3210                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3211                         } else {
3212                                 r->server_name = NULL;
3213                         }
3214                         ndr->flags = _flags_save_string;
3215                 }
3216                 {
3217                         uint32_t _flags_save_string = ndr->flags;
3218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3220                         if (_ptr_user_name) {
3221                                 NDR_PULL_ALLOC(ndr, r->user_name);
3222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3223                         } else {
3224                                 r->user_name = NULL;
3225                         }
3226                         ndr->flags = _flags_save_string;
3227                 }
3228                 {
3229                         uint32_t _flags_save_string = ndr->flags;
3230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3231                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3232                         if (_ptr_document_name) {
3233                                 NDR_PULL_ALLOC(ndr, r->document_name);
3234                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3235                         } else {
3236                                 r->document_name = NULL;
3237                         }
3238                         ndr->flags = _flags_save_string;
3239                 }
3240                 {
3241                         uint32_t _flags_save_string = ndr->flags;
3242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3243                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3244                         if (_ptr_data_type) {
3245                                 NDR_PULL_ALLOC(ndr, r->data_type);
3246                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3247                         } else {
3248                                 r->data_type = NULL;
3249                         }
3250                         ndr->flags = _flags_save_string;
3251                 }
3252                 {
3253                         uint32_t _flags_save_string = ndr->flags;
3254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3255                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3256                         if (_ptr_text_status) {
3257                                 NDR_PULL_ALLOC(ndr, r->text_status);
3258                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3259                         } else {
3260                                 r->text_status = NULL;
3261                         }
3262                         ndr->flags = _flags_save_string;
3263                 }
3264                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3266                 if (r->priority > 99) {
3267                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3268                 }
3269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3272                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3273                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3274         }
3275         if (ndr_flags & NDR_BUFFERS) {
3276                 {
3277                         uint32_t _flags_save_string = ndr->flags;
3278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3279                         if (r->printer_name) {
3280                                 uint32_t _relative_save_offset;
3281                                 _relative_save_offset = ndr->offset;
3282                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3283                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3284                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3285                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3286                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3287                                 if (ndr->offset > ndr->relative_highest_offset) {
3288                                         ndr->relative_highest_offset = ndr->offset;
3289                                 }
3290                                 ndr->offset = _relative_save_offset;
3291                         }
3292                         ndr->flags = _flags_save_string;
3293                 }
3294                 {
3295                         uint32_t _flags_save_string = ndr->flags;
3296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3297                         if (r->server_name) {
3298                                 uint32_t _relative_save_offset;
3299                                 _relative_save_offset = ndr->offset;
3300                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3301                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3302                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3303                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3304                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3305                                 if (ndr->offset > ndr->relative_highest_offset) {
3306                                         ndr->relative_highest_offset = ndr->offset;
3307                                 }
3308                                 ndr->offset = _relative_save_offset;
3309                         }
3310                         ndr->flags = _flags_save_string;
3311                 }
3312                 {
3313                         uint32_t _flags_save_string = ndr->flags;
3314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3315                         if (r->user_name) {
3316                                 uint32_t _relative_save_offset;
3317                                 _relative_save_offset = ndr->offset;
3318                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3319                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3320                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3321                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3322                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3323                                 if (ndr->offset > ndr->relative_highest_offset) {
3324                                         ndr->relative_highest_offset = ndr->offset;
3325                                 }
3326                                 ndr->offset = _relative_save_offset;
3327                         }
3328                         ndr->flags = _flags_save_string;
3329                 }
3330                 {
3331                         uint32_t _flags_save_string = ndr->flags;
3332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3333                         if (r->document_name) {
3334                                 uint32_t _relative_save_offset;
3335                                 _relative_save_offset = ndr->offset;
3336                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3337                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3338                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3339                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3340                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3341                                 if (ndr->offset > ndr->relative_highest_offset) {
3342                                         ndr->relative_highest_offset = ndr->offset;
3343                                 }
3344                                 ndr->offset = _relative_save_offset;
3345                         }
3346                         ndr->flags = _flags_save_string;
3347                 }
3348                 {
3349                         uint32_t _flags_save_string = ndr->flags;
3350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3351                         if (r->data_type) {
3352                                 uint32_t _relative_save_offset;
3353                                 _relative_save_offset = ndr->offset;
3354                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3355                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3356                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3357                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3358                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3359                                 if (ndr->offset > ndr->relative_highest_offset) {
3360                                         ndr->relative_highest_offset = ndr->offset;
3361                                 }
3362                                 ndr->offset = _relative_save_offset;
3363                         }
3364                         ndr->flags = _flags_save_string;
3365                 }
3366                 {
3367                         uint32_t _flags_save_string = ndr->flags;
3368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3369                         if (r->text_status) {
3370                                 uint32_t _relative_save_offset;
3371                                 _relative_save_offset = ndr->offset;
3372                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3373                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3374                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3375                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3376                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3377                                 if (ndr->offset > ndr->relative_highest_offset) {
3378                                         ndr->relative_highest_offset = ndr->offset;
3379                                 }
3380                                 ndr->offset = _relative_save_offset;
3381                         }
3382                         ndr->flags = _flags_save_string;
3383                 }
3384         }
3385         return NDR_ERR_SUCCESS;
3386 }
3387
3388 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3389 {
3390         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3391         ndr->depth++;
3392         ndr_print_uint32(ndr, "job_id", r->job_id);
3393         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3394         ndr->depth++;
3395         if (r->printer_name) {
3396                 ndr_print_string(ndr, "printer_name", r->printer_name);
3397         }
3398         ndr->depth--;
3399         ndr_print_ptr(ndr, "server_name", r->server_name);
3400         ndr->depth++;
3401         if (r->server_name) {
3402                 ndr_print_string(ndr, "server_name", r->server_name);
3403         }
3404         ndr->depth--;
3405         ndr_print_ptr(ndr, "user_name", r->user_name);
3406         ndr->depth++;
3407         if (r->user_name) {
3408                 ndr_print_string(ndr, "user_name", r->user_name);
3409         }
3410         ndr->depth--;
3411         ndr_print_ptr(ndr, "document_name", r->document_name);
3412         ndr->depth++;
3413         if (r->document_name) {
3414                 ndr_print_string(ndr, "document_name", r->document_name);
3415         }
3416         ndr->depth--;
3417         ndr_print_ptr(ndr, "data_type", r->data_type);
3418         ndr->depth++;
3419         if (r->data_type) {
3420                 ndr_print_string(ndr, "data_type", r->data_type);
3421         }
3422         ndr->depth--;
3423         ndr_print_ptr(ndr, "text_status", r->text_status);
3424         ndr->depth++;
3425         if (r->text_status) {
3426                 ndr_print_string(ndr, "text_status", r->text_status);
3427         }
3428         ndr->depth--;
3429         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3430         ndr_print_uint32(ndr, "priority", r->priority);
3431         ndr_print_uint32(ndr, "position", r->position);
3432         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3433         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3434         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3435         ndr->depth--;
3436 }
3437
3438 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3439 {
3440         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3441 }
3442
3443 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3444 {
3445         if (ndr_flags & NDR_SCALARS) {
3446                 NDR_CHECK(ndr_push_align(ndr, 5));
3447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3448                 {
3449                         uint32_t _flags_save_string = ndr->flags;
3450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3451                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3452                         ndr->flags = _flags_save_string;
3453                 }
3454                 {
3455                         uint32_t _flags_save_string = ndr->flags;
3456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3457                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3458                         ndr->flags = _flags_save_string;
3459                 }
3460                 {
3461                         uint32_t _flags_save_string = ndr->flags;
3462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3463                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3464                         ndr->flags = _flags_save_string;
3465                 }
3466                 {
3467                         uint32_t _flags_save_string = ndr->flags;
3468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3469                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3470                         ndr->flags = _flags_save_string;
3471                 }
3472                 {
3473                         uint32_t _flags_save_string = ndr->flags;
3474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3475                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3476                         ndr->flags = _flags_save_string;
3477                 }
3478                 {
3479                         uint32_t _flags_save_string = ndr->flags;
3480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3481                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3482                         ndr->flags = _flags_save_string;
3483                 }
3484                 {
3485                         uint32_t _flags_save_string = ndr->flags;
3486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3487                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3488                         ndr->flags = _flags_save_string;
3489                 }
3490                 {
3491                         uint32_t _flags_save_string = ndr->flags;
3492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3493                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3494                         ndr->flags = _flags_save_string;
3495                 }
3496                 {
3497                         uint32_t _flags_save_string = ndr->flags;
3498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3499                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3500                         ndr->flags = _flags_save_string;
3501                 }
3502                 {
3503                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3505                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3506                         ndr->flags = _flags_save_spoolss_DeviceMode;
3507                 }
3508                 {
3509                         uint32_t _flags_save_string = ndr->flags;
3510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3512                         ndr->flags = _flags_save_string;
3513                 }
3514                 {
3515                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3518                         ndr->flags = _flags_save_spoolss_security_descriptor;
3519                 }
3520                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3527                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3530                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3531         }
3532         if (ndr_flags & NDR_BUFFERS) {
3533                 {
3534                         uint32_t _flags_save_string = ndr->flags;
3535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3536                         if (r->printer_name) {
3537                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3538                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3539                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3540                         }
3541                         ndr->flags = _flags_save_string;
3542                 }
3543                 {
3544                         uint32_t _flags_save_string = ndr->flags;
3545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3546                         if (r->server_name) {
3547                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3548                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3549                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3550                         }
3551                         ndr->flags = _flags_save_string;
3552                 }
3553                 {
3554                         uint32_t _flags_save_string = ndr->flags;
3555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3556                         if (r->user_name) {
3557                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3558                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3559                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3560                         }
3561                         ndr->flags = _flags_save_string;
3562                 }
3563                 {
3564                         uint32_t _flags_save_string = ndr->flags;
3565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3566                         if (r->document_name) {
3567                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3568                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3569                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3570                         }
3571                         ndr->flags = _flags_save_string;
3572                 }
3573                 {
3574                         uint32_t _flags_save_string = ndr->flags;
3575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3576                         if (r->notify_name) {
3577                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3578                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3579                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3580                         }
3581                         ndr->flags = _flags_save_string;
3582                 }
3583                 {
3584                         uint32_t _flags_save_string = ndr->flags;
3585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3586                         if (r->data_type) {
3587                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3589                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3590                         }
3591                         ndr->flags = _flags_save_string;
3592                 }
3593                 {
3594                         uint32_t _flags_save_string = ndr->flags;
3595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3596                         if (r->print_processor) {
3597                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3598                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3599                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3600                         }
3601                         ndr->flags = _flags_save_string;
3602                 }
3603                 {
3604                         uint32_t _flags_save_string = ndr->flags;
3605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3606                         if (r->parameters) {
3607                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3608                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3609                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3610                         }
3611                         ndr->flags = _flags_save_string;
3612                 }
3613                 {
3614                         uint32_t _flags_save_string = ndr->flags;
3615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3616                         if (r->driver_name) {
3617                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
3618                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3619                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
3620                         }
3621                         ndr->flags = _flags_save_string;
3622                 }
3623                 {
3624                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3626                         if (r->devmode) {
3627                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
3628                                 {
3629                                         struct ndr_push *_ndr_devmode;
3630                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3631                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3632                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3633                                 }
3634                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
3635                         }
3636                         ndr->flags = _flags_save_spoolss_DeviceMode;
3637                 }
3638                 {
3639                         uint32_t _flags_save_string = ndr->flags;
3640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3641                         if (r->text_status) {
3642                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3643                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3644                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3645                         }
3646                         ndr->flags = _flags_save_string;
3647                 }
3648                 {
3649                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3651                         if (r->secdesc) {
3652                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
3653                                 {
3654                                         struct ndr_push *_ndr_secdesc;
3655                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3656                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3657                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3658                                 }
3659                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
3660                         }
3661                         ndr->flags = _flags_save_spoolss_security_descriptor;
3662                 }
3663         }
3664         return NDR_ERR_SUCCESS;
3665 }
3666
3667 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3668 {
3669         uint32_t _ptr_printer_name;
3670         TALLOC_CTX *_mem_save_printer_name_0;
3671         uint32_t _ptr_server_name;
3672         TALLOC_CTX *_mem_save_server_name_0;
3673         uint32_t _ptr_user_name;
3674         TALLOC_CTX *_mem_save_user_name_0;
3675         uint32_t _ptr_document_name;
3676         TALLOC_CTX *_mem_save_document_name_0;
3677         uint32_t _ptr_notify_name;
3678         TALLOC_CTX *_mem_save_notify_name_0;
3679         uint32_t _ptr_data_type;
3680         TALLOC_CTX *_mem_save_data_type_0;
3681         uint32_t _ptr_print_processor;
3682         TALLOC_CTX *_mem_save_print_processor_0;
3683         uint32_t _ptr_parameters;
3684         TALLOC_CTX *_mem_save_parameters_0;
3685         uint32_t _ptr_driver_name;
3686         TALLOC_CTX *_mem_save_driver_name_0;
3687         uint32_t _ptr_devmode;
3688         TALLOC_CTX *_mem_save_devmode_0;
3689         uint32_t _ptr_text_status;
3690         TALLOC_CTX *_mem_save_text_status_0;
3691         uint32_t _ptr_secdesc;
3692         TALLOC_CTX *_mem_save_secdesc_0;
3693         if (ndr_flags & NDR_SCALARS) {
3694                 NDR_CHECK(ndr_pull_align(ndr, 5));
3695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3696                 {
3697                         uint32_t _flags_save_string = ndr->flags;
3698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3699                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3700                         if (_ptr_printer_name) {
3701                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3702                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3703                         } else {
3704                                 r->printer_name = NULL;
3705                         }
3706                         ndr->flags = _flags_save_string;
3707                 }
3708                 {
3709                         uint32_t _flags_save_string = ndr->flags;
3710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3712                         if (_ptr_server_name) {
3713                                 NDR_PULL_ALLOC(ndr, r->server_name);
3714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3715                         } else {
3716                                 r->server_name = NULL;
3717                         }
3718                         ndr->flags = _flags_save_string;
3719                 }
3720                 {
3721                         uint32_t _flags_save_string = ndr->flags;
3722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3723                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3724                         if (_ptr_user_name) {
3725                                 NDR_PULL_ALLOC(ndr, r->user_name);
3726                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3727                         } else {
3728                                 r->user_name = NULL;
3729                         }
3730                         ndr->flags = _flags_save_string;
3731                 }
3732                 {
3733                         uint32_t _flags_save_string = ndr->flags;
3734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3735                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3736                         if (_ptr_document_name) {
3737                                 NDR_PULL_ALLOC(ndr, r->document_name);
3738                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3739                         } else {
3740                                 r->document_name = NULL;
3741                         }
3742                         ndr->flags = _flags_save_string;
3743                 }
3744                 {
3745                         uint32_t _flags_save_string = ndr->flags;
3746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3747                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3748                         if (_ptr_notify_name) {
3749                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3750                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3751                         } else {
3752                                 r->notify_name = NULL;
3753                         }
3754                         ndr->flags = _flags_save_string;
3755                 }
3756                 {
3757                         uint32_t _flags_save_string = ndr->flags;
3758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3759                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3760                         if (_ptr_data_type) {
3761                                 NDR_PULL_ALLOC(ndr, r->data_type);
3762                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3763                         } else {
3764                                 r->data_type = NULL;
3765                         }
3766                         ndr->flags = _flags_save_string;
3767                 }
3768                 {
3769                         uint32_t _flags_save_string = ndr->flags;
3770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3771                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3772                         if (_ptr_print_processor) {
3773                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3774                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3775                         } else {
3776                                 r->print_processor = NULL;
3777                         }
3778                         ndr->flags = _flags_save_string;
3779                 }
3780                 {
3781                         uint32_t _flags_save_string = ndr->flags;
3782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3783                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3784                         if (_ptr_parameters) {
3785                                 NDR_PULL_ALLOC(ndr, r->parameters);
3786                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3787                         } else {
3788                                 r->parameters = NULL;
3789                         }
3790                         ndr->flags = _flags_save_string;
3791                 }
3792                 {
3793                         uint32_t _flags_save_string = ndr->flags;
3794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3795                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3796                         if (_ptr_driver_name) {
3797                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3798                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3799                         } else {
3800                                 r->driver_name = NULL;
3801                         }
3802                         ndr->flags = _flags_save_string;
3803                 }
3804                 {
3805                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3807                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3808                         if (_ptr_devmode) {
3809                                 NDR_PULL_ALLOC(ndr, r->devmode);
3810                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3811                         } else {
3812                                 r->devmode = NULL;
3813                         }
3814                         ndr->flags = _flags_save_spoolss_DeviceMode;
3815                 }
3816                 {
3817                         uint32_t _flags_save_string = ndr->flags;
3818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3819                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3820                         if (_ptr_text_status) {
3821                                 NDR_PULL_ALLOC(ndr, r->text_status);
3822                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3823                         } else {
3824                                 r->text_status = NULL;
3825                         }
3826                         ndr->flags = _flags_save_string;
3827                 }
3828                 {
3829                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3832                         if (_ptr_secdesc) {
3833                                 NDR_PULL_ALLOC(ndr, r->secdesc);
3834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3835                         } else {
3836                                 r->secdesc = NULL;
3837                         }
3838                         ndr->flags = _flags_save_spoolss_security_descriptor;
3839                 }
3840                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3842                 if (r->priority > 99) {
3843                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3844                 }
3845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3850                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3853                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3854         }
3855         if (ndr_flags & NDR_BUFFERS) {
3856                 {
3857                         uint32_t _flags_save_string = ndr->flags;
3858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3859                         if (r->printer_name) {
3860                                 uint32_t _relative_save_offset;
3861                                 _relative_save_offset = ndr->offset;
3862                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3863                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3864                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3865                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3866                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3867                                 if (ndr->offset > ndr->relative_highest_offset) {
3868                                         ndr->relative_highest_offset = ndr->offset;
3869                                 }
3870                                 ndr->offset = _relative_save_offset;
3871                         }
3872                         ndr->flags = _flags_save_string;
3873                 }
3874                 {
3875                         uint32_t _flags_save_string = ndr->flags;
3876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3877                         if (r->server_name) {
3878                                 uint32_t _relative_save_offset;
3879                                 _relative_save_offset = ndr->offset;
3880                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3881                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3882                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3883                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3884                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3885                                 if (ndr->offset > ndr->relative_highest_offset) {
3886                                         ndr->relative_highest_offset = ndr->offset;
3887                                 }
3888                                 ndr->offset = _relative_save_offset;
3889                         }
3890                         ndr->flags = _flags_save_string;
3891                 }
3892                 {
3893                         uint32_t _flags_save_string = ndr->flags;
3894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3895                         if (r->user_name) {
3896                                 uint32_t _relative_save_offset;
3897                                 _relative_save_offset = ndr->offset;
3898                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3899                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3900                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3901                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3902                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3903                                 if (ndr->offset > ndr->relative_highest_offset) {
3904                                         ndr->relative_highest_offset = ndr->offset;
3905                                 }
3906                                 ndr->offset = _relative_save_offset;
3907                         }
3908                         ndr->flags = _flags_save_string;
3909                 }
3910                 {
3911                         uint32_t _flags_save_string = ndr->flags;
3912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3913                         if (r->document_name) {
3914                                 uint32_t _relative_save_offset;
3915                                 _relative_save_offset = ndr->offset;
3916                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3917                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3918                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3919                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3920                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3921                                 if (ndr->offset > ndr->relative_highest_offset) {
3922                                         ndr->relative_highest_offset = ndr->offset;
3923                                 }
3924                                 ndr->offset = _relative_save_offset;
3925                         }
3926                         ndr->flags = _flags_save_string;
3927                 }
3928                 {
3929                         uint32_t _flags_save_string = ndr->flags;
3930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3931                         if (r->notify_name) {
3932                                 uint32_t _relative_save_offset;
3933                                 _relative_save_offset = ndr->offset;
3934                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3935                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3936                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3937                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3938                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3939                                 if (ndr->offset > ndr->relative_highest_offset) {
3940                                         ndr->relative_highest_offset = ndr->offset;
3941                                 }
3942                                 ndr->offset = _relative_save_offset;
3943                         }
3944                         ndr->flags = _flags_save_string;
3945                 }
3946                 {
3947                         uint32_t _flags_save_string = ndr->flags;
3948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3949                         if (r->data_type) {
3950                                 uint32_t _relative_save_offset;
3951                                 _relative_save_offset = ndr->offset;
3952                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3953                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3954                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3955                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3956                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3957                                 if (ndr->offset > ndr->relative_highest_offset) {
3958                                         ndr->relative_highest_offset = ndr->offset;
3959                                 }
3960                                 ndr->offset = _relative_save_offset;
3961                         }
3962                         ndr->flags = _flags_save_string;
3963                 }
3964                 {
3965                         uint32_t _flags_save_string = ndr->flags;
3966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3967                         if (r->print_processor) {
3968                                 uint32_t _relative_save_offset;
3969                                 _relative_save_offset = ndr->offset;
3970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3971                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3972                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3975                                 if (ndr->offset > ndr->relative_highest_offset) {
3976                                         ndr->relative_highest_offset = ndr->offset;
3977                                 }
3978                                 ndr->offset = _relative_save_offset;
3979                         }
3980                         ndr->flags = _flags_save_string;
3981                 }
3982                 {
3983                         uint32_t _flags_save_string = ndr->flags;
3984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3985                         if (r->parameters) {
3986                                 uint32_t _relative_save_offset;
3987                                 _relative_save_offset = ndr->offset;
3988                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3989                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3990                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3991                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3992                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3993                                 if (ndr->offset > ndr->relative_highest_offset) {
3994                                         ndr->relative_highest_offset = ndr->offset;
3995                                 }
3996                                 ndr->offset = _relative_save_offset;
3997                         }
3998                         ndr->flags = _flags_save_string;
3999                 }
4000                 {
4001                         uint32_t _flags_save_string = ndr->flags;
4002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4003                         if (r->driver_name) {
4004                                 uint32_t _relative_save_offset;
4005                                 _relative_save_offset = ndr->offset;
4006                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4007                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4008                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4009                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4010                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4011                                 if (ndr->offset > ndr->relative_highest_offset) {
4012                                         ndr->relative_highest_offset = ndr->offset;
4013                                 }
4014                                 ndr->offset = _relative_save_offset;
4015                         }
4016                         ndr->flags = _flags_save_string;
4017                 }
4018                 {
4019                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4021                         if (r->devmode) {
4022                                 uint32_t _relative_save_offset;
4023                                 _relative_save_offset = ndr->offset;
4024                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4025                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4026                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4027                                 {
4028                                         struct ndr_pull *_ndr_devmode;
4029                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4030                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4031                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
4032                                 }
4033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4034                                 if (ndr->offset > ndr->relative_highest_offset) {
4035                                         ndr->relative_highest_offset = ndr->offset;
4036                                 }
4037                                 ndr->offset = _relative_save_offset;
4038                         }
4039                         ndr->flags = _flags_save_spoolss_DeviceMode;
4040                 }
4041                 {
4042                         uint32_t _flags_save_string = ndr->flags;
4043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4044                         if (r->text_status) {
4045                                 uint32_t _relative_save_offset;
4046                                 _relative_save_offset = ndr->offset;
4047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4048                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4049                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4052                                 if (ndr->offset > ndr->relative_highest_offset) {
4053                                         ndr->relative_highest_offset = ndr->offset;
4054                                 }
4055                                 ndr->offset = _relative_save_offset;
4056                         }
4057                         ndr->flags = _flags_save_string;
4058                 }
4059                 {
4060                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4062                         if (r->secdesc) {
4063                                 uint32_t _relative_save_offset;
4064                                 _relative_save_offset = ndr->offset;
4065                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4066                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4067                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4068                                 {
4069                                         struct ndr_pull *_ndr_secdesc;
4070                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4071                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4072                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4073                                 }
4074                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4075                                 if (ndr->offset > ndr->relative_highest_offset) {
4076                                         ndr->relative_highest_offset = ndr->offset;
4077                                 }
4078                                 ndr->offset = _relative_save_offset;
4079                         }
4080                         ndr->flags = _flags_save_spoolss_security_descriptor;
4081                 }
4082         }
4083         return NDR_ERR_SUCCESS;
4084 }
4085
4086 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4087 {
4088         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4089         ndr->depth++;
4090         ndr_print_uint32(ndr, "job_id", r->job_id);
4091         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4092         ndr->depth++;
4093         if (r->printer_name) {
4094                 ndr_print_string(ndr, "printer_name", r->printer_name);
4095         }
4096         ndr->depth--;
4097         ndr_print_ptr(ndr, "server_name", r->server_name);
4098         ndr->depth++;
4099         if (r->server_name) {
4100                 ndr_print_string(ndr, "server_name", r->server_name);
4101         }
4102         ndr->depth--;
4103         ndr_print_ptr(ndr, "user_name", r->user_name);
4104         ndr->depth++;
4105         if (r->user_name) {
4106                 ndr_print_string(ndr, "user_name", r->user_name);
4107         }
4108         ndr->depth--;
4109         ndr_print_ptr(ndr, "document_name", r->document_name);
4110         ndr->depth++;
4111         if (r->document_name) {
4112                 ndr_print_string(ndr, "document_name", r->document_name);
4113         }
4114         ndr->depth--;
4115         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4116         ndr->depth++;
4117         if (r->notify_name) {
4118                 ndr_print_string(ndr, "notify_name", r->notify_name);
4119         }
4120         ndr->depth--;
4121         ndr_print_ptr(ndr, "data_type", r->data_type);
4122         ndr->depth++;
4123         if (r->data_type) {
4124                 ndr_print_string(ndr, "data_type", r->data_type);
4125         }
4126         ndr->depth--;
4127         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4128         ndr->depth++;
4129         if (r->print_processor) {
4130                 ndr_print_string(ndr, "print_processor", r->print_processor);
4131         }
4132         ndr->depth--;
4133         ndr_print_ptr(ndr, "parameters", r->parameters);
4134         ndr->depth++;
4135         if (r->parameters) {
4136                 ndr_print_string(ndr, "parameters", r->parameters);
4137         }
4138         ndr->depth--;
4139         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4140         ndr->depth++;
4141         if (r->driver_name) {
4142                 ndr_print_string(ndr, "driver_name", r->driver_name);
4143         }
4144         ndr->depth--;
4145         ndr_print_ptr(ndr, "devmode", r->devmode);
4146         ndr->depth++;
4147         if (r->devmode) {
4148                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4149         }
4150         ndr->depth--;
4151         ndr_print_ptr(ndr, "text_status", r->text_status);
4152         ndr->depth++;
4153         if (r->text_status) {
4154                 ndr_print_string(ndr, "text_status", r->text_status);
4155         }
4156         ndr->depth--;
4157         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4158         ndr->depth++;
4159         if (r->secdesc) {
4160                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4161         }
4162         ndr->depth--;
4163         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4164         ndr_print_uint32(ndr, "priority", r->priority);
4165         ndr_print_uint32(ndr, "position", r->position);
4166         ndr_print_uint32(ndr, "start_time", r->start_time);
4167         ndr_print_uint32(ndr, "until_time", r->until_time);
4168         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4169         ndr_print_uint32(ndr, "size", r->size);
4170         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4171         ndr_print_uint32(ndr, "time", r->time);
4172         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4173         ndr->depth--;
4174 }
4175
4176 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4177 {
4178         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4179 }
4180
4181 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4182 {
4183         if (ndr_flags & NDR_SCALARS) {
4184                 NDR_CHECK(ndr_push_align(ndr, 4));
4185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4188                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4189         }
4190         if (ndr_flags & NDR_BUFFERS) {
4191         }
4192         return NDR_ERR_SUCCESS;
4193 }
4194
4195 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4196 {
4197         if (ndr_flags & NDR_SCALARS) {
4198                 NDR_CHECK(ndr_pull_align(ndr, 4));
4199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4202                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4203         }
4204         if (ndr_flags & NDR_BUFFERS) {
4205         }
4206         return NDR_ERR_SUCCESS;
4207 }
4208
4209 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4210 {
4211         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4212         ndr->depth++;
4213         ndr_print_uint32(ndr, "job_id", r->job_id);
4214         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4215         ndr_print_uint32(ndr, "reserved", r->reserved);
4216         ndr->depth--;
4217 }
4218
4219 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4220 {
4221         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4222 }
4223
4224 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4225 {
4226         if (ndr_flags & NDR_SCALARS) {
4227                 NDR_CHECK(ndr_push_align(ndr, 5));
4228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4229                 {
4230                         uint32_t _flags_save_string = ndr->flags;
4231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4232                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4233                         ndr->flags = _flags_save_string;
4234                 }
4235                 {
4236                         uint32_t _flags_save_string = ndr->flags;
4237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4238                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4239                         ndr->flags = _flags_save_string;
4240                 }
4241                 {
4242                         uint32_t _flags_save_string = ndr->flags;
4243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4244                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4245                         ndr->flags = _flags_save_string;
4246                 }
4247                 {
4248                         uint32_t _flags_save_string = ndr->flags;
4249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4250                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4251                         ndr->flags = _flags_save_string;
4252                 }
4253                 {
4254                         uint32_t _flags_save_string = ndr->flags;
4255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4256                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4257                         ndr->flags = _flags_save_string;
4258                 }
4259                 {
4260                         uint32_t _flags_save_string = ndr->flags;
4261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4262                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4263                         ndr->flags = _flags_save_string;
4264                 }
4265                 {
4266                         uint32_t _flags_save_string = ndr->flags;
4267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4268                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4269                         ndr->flags = _flags_save_string;
4270                 }
4271                 {
4272                         uint32_t _flags_save_string = ndr->flags;
4273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4274                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4275                         ndr->flags = _flags_save_string;
4276                 }
4277                 {
4278                         uint32_t _flags_save_string = ndr->flags;
4279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4280                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4281                         ndr->flags = _flags_save_string;
4282                 }
4283                 {
4284                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4286                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4287                         ndr->flags = _flags_save_spoolss_DeviceMode;
4288                 }
4289                 {
4290                         uint32_t _flags_save_string = ndr->flags;
4291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4292                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4293                         ndr->flags = _flags_save_string;
4294                 }
4295                 {
4296                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4298                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4299                         ndr->flags = _flags_save_spoolss_security_descriptor;
4300                 }
4301                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4308                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4312                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4313         }
4314         if (ndr_flags & NDR_BUFFERS) {
4315                 {
4316                         uint32_t _flags_save_string = ndr->flags;
4317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4318                         if (r->printer_name) {
4319                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
4320                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4321                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
4322                         }
4323                         ndr->flags = _flags_save_string;
4324                 }
4325                 {
4326                         uint32_t _flags_save_string = ndr->flags;
4327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4328                         if (r->server_name) {
4329                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
4330                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4331                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
4332                         }
4333                         ndr->flags = _flags_save_string;
4334                 }
4335                 {
4336                         uint32_t _flags_save_string = ndr->flags;
4337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4338                         if (r->user_name) {
4339                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
4340                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4341                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
4342                         }
4343                         ndr->flags = _flags_save_string;
4344                 }
4345                 {
4346                         uint32_t _flags_save_string = ndr->flags;
4347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4348                         if (r->document_name) {
4349                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
4350                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4351                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
4352                         }
4353                         ndr->flags = _flags_save_string;
4354                 }
4355                 {
4356                         uint32_t _flags_save_string = ndr->flags;
4357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4358                         if (r->notify_name) {
4359                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
4360                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4361                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
4362                         }
4363                         ndr->flags = _flags_save_string;
4364                 }
4365                 {
4366                         uint32_t _flags_save_string = ndr->flags;
4367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4368                         if (r->data_type) {
4369                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
4370                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4371                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
4372                         }
4373                         ndr->flags = _flags_save_string;
4374                 }
4375                 {
4376                         uint32_t _flags_save_string = ndr->flags;
4377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4378                         if (r->print_processor) {
4379                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
4380                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4381                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
4382                         }
4383                         ndr->flags = _flags_save_string;
4384                 }
4385                 {
4386                         uint32_t _flags_save_string = ndr->flags;
4387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4388                         if (r->parameters) {
4389                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
4390                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4391                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
4392                         }
4393                         ndr->flags = _flags_save_string;
4394                 }
4395                 {
4396                         uint32_t _flags_save_string = ndr->flags;
4397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4398                         if (r->driver_name) {
4399                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
4400                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4401                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
4402                         }
4403                         ndr->flags = _flags_save_string;
4404                 }
4405                 {
4406                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4408                         if (r->devmode) {
4409                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
4410                                 {
4411                                         struct ndr_push *_ndr_devmode;
4412                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4413                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4414                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
4415                                 }
4416                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
4417                         }
4418                         ndr->flags = _flags_save_spoolss_DeviceMode;
4419                 }
4420                 {
4421                         uint32_t _flags_save_string = ndr->flags;
4422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4423                         if (r->text_status) {
4424                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
4425                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4426                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
4427                         }
4428                         ndr->flags = _flags_save_string;
4429                 }
4430                 {
4431                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4433                         if (r->secdesc) {
4434                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
4435                                 {
4436                                         struct ndr_push *_ndr_secdesc;
4437                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4438                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4439                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4440                                 }
4441                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
4442                         }
4443                         ndr->flags = _flags_save_spoolss_security_descriptor;
4444                 }
4445         }
4446         return NDR_ERR_SUCCESS;
4447 }
4448
4449 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4450 {
4451         uint32_t _ptr_printer_name;
4452         TALLOC_CTX *_mem_save_printer_name_0;
4453         uint32_t _ptr_server_name;
4454         TALLOC_CTX *_mem_save_server_name_0;
4455         uint32_t _ptr_user_name;
4456         TALLOC_CTX *_mem_save_user_name_0;
4457         uint32_t _ptr_document_name;
4458         TALLOC_CTX *_mem_save_document_name_0;
4459         uint32_t _ptr_notify_name;
4460         TALLOC_CTX *_mem_save_notify_name_0;
4461         uint32_t _ptr_data_type;
4462         TALLOC_CTX *_mem_save_data_type_0;
4463         uint32_t _ptr_print_processor;
4464         TALLOC_CTX *_mem_save_print_processor_0;
4465         uint32_t _ptr_parameters;
4466         TALLOC_CTX *_mem_save_parameters_0;
4467         uint32_t _ptr_driver_name;
4468         TALLOC_CTX *_mem_save_driver_name_0;
4469         uint32_t _ptr_devmode;
4470         TALLOC_CTX *_mem_save_devmode_0;
4471         uint32_t _ptr_text_status;
4472         TALLOC_CTX *_mem_save_text_status_0;
4473         uint32_t _ptr_secdesc;
4474         TALLOC_CTX *_mem_save_secdesc_0;
4475         if (ndr_flags & NDR_SCALARS) {
4476                 NDR_CHECK(ndr_pull_align(ndr, 5));
4477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4478                 {
4479                         uint32_t _flags_save_string = ndr->flags;
4480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4481                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4482                         if (_ptr_printer_name) {
4483                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4484                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4485                         } else {
4486                                 r->printer_name = NULL;
4487                         }
4488                         ndr->flags = _flags_save_string;
4489                 }
4490                 {
4491                         uint32_t _flags_save_string = ndr->flags;
4492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4493                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4494                         if (_ptr_server_name) {
4495                                 NDR_PULL_ALLOC(ndr, r->server_name);
4496                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4497                         } else {
4498                                 r->server_name = NULL;
4499                         }
4500                         ndr->flags = _flags_save_string;
4501                 }
4502                 {
4503                         uint32_t _flags_save_string = ndr->flags;
4504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4505                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4506                         if (_ptr_user_name) {
4507                                 NDR_PULL_ALLOC(ndr, r->user_name);
4508                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4509                         } else {
4510                                 r->user_name = NULL;
4511                         }
4512                         ndr->flags = _flags_save_string;
4513                 }
4514                 {
4515                         uint32_t _flags_save_string = ndr->flags;
4516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4517                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4518                         if (_ptr_document_name) {
4519                                 NDR_PULL_ALLOC(ndr, r->document_name);
4520                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4521                         } else {
4522                                 r->document_name = NULL;
4523                         }
4524                         ndr->flags = _flags_save_string;
4525                 }
4526                 {
4527                         uint32_t _flags_save_string = ndr->flags;
4528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4529                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4530                         if (_ptr_notify_name) {
4531                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4532                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4533                         } else {
4534                                 r->notify_name = NULL;
4535                         }
4536                         ndr->flags = _flags_save_string;
4537                 }
4538                 {
4539                         uint32_t _flags_save_string = ndr->flags;
4540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4541                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4542                         if (_ptr_data_type) {
4543                                 NDR_PULL_ALLOC(ndr, r->data_type);
4544                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4545                         } else {
4546                                 r->data_type = NULL;
4547                         }
4548                         ndr->flags = _flags_save_string;
4549                 }
4550                 {
4551                         uint32_t _flags_save_string = ndr->flags;
4552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4553                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4554                         if (_ptr_print_processor) {
4555                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4556                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4557                         } else {
4558                                 r->print_processor = NULL;
4559                         }
4560                         ndr->flags = _flags_save_string;
4561                 }
4562                 {
4563                         uint32_t _flags_save_string = ndr->flags;
4564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4565                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4566                         if (_ptr_parameters) {
4567                                 NDR_PULL_ALLOC(ndr, r->parameters);
4568                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4569                         } else {
4570                                 r->parameters = NULL;
4571                         }
4572                         ndr->flags = _flags_save_string;
4573                 }
4574                 {
4575                         uint32_t _flags_save_string = ndr->flags;
4576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4577                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4578                         if (_ptr_driver_name) {
4579                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4580                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4581                         } else {
4582                                 r->driver_name = NULL;
4583                         }
4584                         ndr->flags = _flags_save_string;
4585                 }
4586                 {
4587                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4589                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4590                         if (_ptr_devmode) {
4591                                 NDR_PULL_ALLOC(ndr, r->devmode);
4592                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4593                         } else {
4594                                 r->devmode = NULL;
4595                         }
4596                         ndr->flags = _flags_save_spoolss_DeviceMode;
4597                 }
4598                 {
4599                         uint32_t _flags_save_string = ndr->flags;
4600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4601                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4602                         if (_ptr_text_status) {
4603                                 NDR_PULL_ALLOC(ndr, r->text_status);
4604                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4605                         } else {
4606                                 r->text_status = NULL;
4607                         }
4608                         ndr->flags = _flags_save_string;
4609                 }
4610                 {
4611                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4613                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4614                         if (_ptr_secdesc) {
4615                                 NDR_PULL_ALLOC(ndr, r->secdesc);
4616                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4617                         } else {
4618                                 r->secdesc = NULL;
4619                         }
4620                         ndr->flags = _flags_save_spoolss_security_descriptor;
4621                 }
4622                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4624                 if (r->priority > 99) {
4625                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4626                 }
4627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4632                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4636                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4637         }
4638         if (ndr_flags & NDR_BUFFERS) {
4639                 {
4640                         uint32_t _flags_save_string = ndr->flags;
4641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4642                         if (r->printer_name) {
4643                                 uint32_t _relative_save_offset;
4644                                 _relative_save_offset = ndr->offset;
4645                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4646                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4647                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4648                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4649                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4650                                 if (ndr->offset > ndr->relative_highest_offset) {
4651                                         ndr->relative_highest_offset = ndr->offset;
4652                                 }
4653                                 ndr->offset = _relative_save_offset;
4654                         }
4655                         ndr->flags = _flags_save_string;
4656                 }
4657                 {
4658                         uint32_t _flags_save_string = ndr->flags;
4659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4660                         if (r->server_name) {
4661                                 uint32_t _relative_save_offset;
4662                                 _relative_save_offset = ndr->offset;
4663                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4664                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4665                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4666                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4667                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4668                                 if (ndr->offset > ndr->relative_highest_offset) {
4669                                         ndr->relative_highest_offset = ndr->offset;
4670                                 }
4671                                 ndr->offset = _relative_save_offset;
4672                         }
4673                         ndr->flags = _flags_save_string;
4674                 }
4675                 {
4676                         uint32_t _flags_save_string = ndr->flags;
4677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4678                         if (r->user_name) {
4679                                 uint32_t _relative_save_offset;
4680                                 _relative_save_offset = ndr->offset;
4681                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4682                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4683                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4684                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4685                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4686                                 if (ndr->offset > ndr->relative_highest_offset) {
4687                                         ndr->relative_highest_offset = ndr->offset;
4688                                 }
4689                                 ndr->offset = _relative_save_offset;
4690                         }
4691                         ndr->flags = _flags_save_string;
4692                 }
4693                 {
4694                         uint32_t _flags_save_string = ndr->flags;
4695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4696                         if (r->document_name) {
4697                                 uint32_t _relative_save_offset;
4698                                 _relative_save_offset = ndr->offset;
4699                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4700                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4701                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4702                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4703                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4704                                 if (ndr->offset > ndr->relative_highest_offset) {
4705                                         ndr->relative_highest_offset = ndr->offset;
4706                                 }
4707                                 ndr->offset = _relative_save_offset;
4708                         }
4709                         ndr->flags = _flags_save_string;
4710                 }
4711                 {
4712                         uint32_t _flags_save_string = ndr->flags;
4713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4714                         if (r->notify_name) {
4715                                 uint32_t _relative_save_offset;
4716                                 _relative_save_offset = ndr->offset;
4717                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4718                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4719                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4720                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4721                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4722                                 if (ndr->offset > ndr->relative_highest_offset) {
4723                                         ndr->relative_highest_offset = ndr->offset;
4724                                 }
4725                                 ndr->offset = _relative_save_offset;
4726                         }
4727                         ndr->flags = _flags_save_string;
4728                 }
4729                 {
4730                         uint32_t _flags_save_string = ndr->flags;
4731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4732                         if (r->data_type) {
4733                                 uint32_t _relative_save_offset;
4734                                 _relative_save_offset = ndr->offset;
4735                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4736                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4737                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4738                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4739                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4740                                 if (ndr->offset > ndr->relative_highest_offset) {
4741                                         ndr->relative_highest_offset = ndr->offset;
4742                                 }
4743                                 ndr->offset = _relative_save_offset;
4744                         }
4745                         ndr->flags = _flags_save_string;
4746                 }
4747                 {
4748                         uint32_t _flags_save_string = ndr->flags;
4749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4750                         if (r->print_processor) {
4751                                 uint32_t _relative_save_offset;
4752                                 _relative_save_offset = ndr->offset;
4753                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4754                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4755                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4756                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4757                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4758                                 if (ndr->offset > ndr->relative_highest_offset) {
4759                                         ndr->relative_highest_offset = ndr->offset;
4760                                 }
4761                                 ndr->offset = _relative_save_offset;
4762                         }
4763                         ndr->flags = _flags_save_string;
4764                 }
4765                 {
4766                         uint32_t _flags_save_string = ndr->flags;
4767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4768                         if (r->parameters) {
4769                                 uint32_t _relative_save_offset;
4770                                 _relative_save_offset = ndr->offset;
4771                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4772                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4773                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4774                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4775                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4776                                 if (ndr->offset > ndr->relative_highest_offset) {
4777                                         ndr->relative_highest_offset = ndr->offset;
4778                                 }
4779                                 ndr->offset = _relative_save_offset;
4780                         }
4781                         ndr->flags = _flags_save_string;
4782                 }
4783                 {
4784                         uint32_t _flags_save_string = ndr->flags;
4785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4786                         if (r->driver_name) {
4787                                 uint32_t _relative_save_offset;
4788                                 _relative_save_offset = ndr->offset;
4789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4790                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4791                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4794                                 if (ndr->offset > ndr->relative_highest_offset) {
4795                                         ndr->relative_highest_offset = ndr->offset;
4796                                 }
4797                                 ndr->offset = _relative_save_offset;
4798                         }
4799                         ndr->flags = _flags_save_string;
4800                 }
4801                 {
4802                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4804                         if (r->devmode) {
4805                                 uint32_t _relative_save_offset;
4806                                 _relative_save_offset = ndr->offset;
4807                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4808                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4809                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4810                                 {
4811                                         struct ndr_pull *_ndr_devmode;
4812                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4813                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4814                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
4815                                 }
4816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4817                                 if (ndr->offset > ndr->relative_highest_offset) {
4818                                         ndr->relative_highest_offset = ndr->offset;
4819                                 }
4820                                 ndr->offset = _relative_save_offset;
4821                         }
4822                         ndr->flags = _flags_save_spoolss_DeviceMode;
4823                 }
4824                 {
4825                         uint32_t _flags_save_string = ndr->flags;
4826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4827                         if (r->text_status) {
4828                                 uint32_t _relative_save_offset;
4829                                 _relative_save_offset = ndr->offset;
4830                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4831                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4832                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4833                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4834                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4835                                 if (ndr->offset > ndr->relative_highest_offset) {
4836                                         ndr->relative_highest_offset = ndr->offset;
4837                                 }
4838                                 ndr->offset = _relative_save_offset;
4839                         }
4840                         ndr->flags = _flags_save_string;
4841                 }
4842                 {
4843                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4845                         if (r->secdesc) {
4846                                 uint32_t _relative_save_offset;
4847                                 _relative_save_offset = ndr->offset;
4848                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4849                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4850                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4851                                 {
4852                                         struct ndr_pull *_ndr_secdesc;
4853                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4854                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4855                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4856                                 }
4857                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4858                                 if (ndr->offset > ndr->relative_highest_offset) {
4859                                         ndr->relative_highest_offset = ndr->offset;
4860                                 }
4861                                 ndr->offset = _relative_save_offset;
4862                         }
4863                         ndr->flags = _flags_save_spoolss_security_descriptor;
4864                 }
4865         }
4866         return NDR_ERR_SUCCESS;
4867 }
4868
4869 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4870 {
4871         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4872         ndr->depth++;
4873         ndr_print_uint32(ndr, "job_id", r->job_id);
4874         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4875         ndr->depth++;
4876         if (r->printer_name) {
4877                 ndr_print_string(ndr, "printer_name", r->printer_name);
4878         }
4879         ndr->depth--;
4880         ndr_print_ptr(ndr, "server_name", r->server_name);
4881         ndr->depth++;
4882         if (r->server_name) {
4883                 ndr_print_string(ndr, "server_name", r->server_name);
4884         }
4885         ndr->depth--;
4886         ndr_print_ptr(ndr, "user_name", r->user_name);
4887         ndr->depth++;
4888         if (r->user_name) {
4889                 ndr_print_string(ndr, "user_name", r->user_name);
4890         }
4891         ndr->depth--;
4892         ndr_print_ptr(ndr, "document_name", r->document_name);
4893         ndr->depth++;
4894         if (r->document_name) {
4895                 ndr_print_string(ndr, "document_name", r->document_name);
4896         }
4897         ndr->depth--;
4898         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4899         ndr->depth++;
4900         if (r->notify_name) {
4901                 ndr_print_string(ndr, "notify_name", r->notify_name);
4902         }
4903         ndr->depth--;
4904         ndr_print_ptr(ndr, "data_type", r->data_type);
4905         ndr->depth++;
4906         if (r->data_type) {
4907                 ndr_print_string(ndr, "data_type", r->data_type);
4908         }
4909         ndr->depth--;
4910         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4911         ndr->depth++;
4912         if (r->print_processor) {
4913                 ndr_print_string(ndr, "print_processor", r->print_processor);
4914         }
4915         ndr->depth--;
4916         ndr_print_ptr(ndr, "parameters", r->parameters);
4917         ndr->depth++;
4918         if (r->parameters) {
4919                 ndr_print_string(ndr, "parameters", r->parameters);
4920         }
4921         ndr->depth--;
4922         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4923         ndr->depth++;
4924         if (r->driver_name) {
4925                 ndr_print_string(ndr, "driver_name", r->driver_name);
4926         }
4927         ndr->depth--;
4928         ndr_print_ptr(ndr, "devmode", r->devmode);
4929         ndr->depth++;
4930         if (r->devmode) {
4931                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4932         }
4933         ndr->depth--;
4934         ndr_print_ptr(ndr, "text_status", r->text_status);
4935         ndr->depth++;
4936         if (r->text_status) {
4937                 ndr_print_string(ndr, "text_status", r->text_status);
4938         }
4939         ndr->depth--;
4940         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4941         ndr->depth++;
4942         if (r->secdesc) {
4943                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4944         }
4945         ndr->depth--;
4946         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4947         ndr_print_uint32(ndr, "priority", r->priority);
4948         ndr_print_uint32(ndr, "position", r->position);
4949         ndr_print_uint32(ndr, "start_time", r->start_time);
4950         ndr_print_uint32(ndr, "until_time", r->until_time);
4951         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4952         ndr_print_uint32(ndr, "size", r->size);
4953         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4954         ndr_print_uint32(ndr, "time", r->time);
4955         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4956         ndr_print_uint32(ndr, "size_high", r->size_high);
4957         ndr->depth--;
4958 }
4959
4960 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4961 {
4962         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4963 }
4964
4965 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4966 {
4967         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4968         {
4969                 uint32_t _flags_save_UNION = ndr->flags;
4970                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4971                 if (ndr_flags & NDR_SCALARS) {
4972                         int level = ndr_push_get_switch_value(ndr, r);
4973                         NDR_CHECK(ndr_push_union_align(ndr, 5));
4974                         switch (level) {
4975                                 case 1: {
4976                                         NDR_CHECK(ndr_push_align(ndr, 5));
4977                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4978                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4979                                 break; }
4980
4981                                 case 2: {
4982                                         NDR_CHECK(ndr_push_align(ndr, 5));
4983                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4984                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4985                                 break; }
4986
4987                                 case 3: {
4988                                         NDR_CHECK(ndr_push_align(ndr, 4));
4989                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4990                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4991                                 break; }
4992
4993                                 case 4: {
4994                                         NDR_CHECK(ndr_push_align(ndr, 5));
4995                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4996                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4997                                 break; }
4998
4999                                 default: {
5000                                 break; }
5001
5002                         }
5003                 }
5004                 if (ndr_flags & NDR_BUFFERS) {
5005                         int level = ndr_push_get_switch_value(ndr, r);
5006                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
5007                         switch (level) {
5008                                 case 1:
5009                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5010                                 break;
5011
5012                                 case 2:
5013                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5014                                 break;
5015
5016                                 case 3:
5017                                 break;
5018
5019                                 case 4:
5020                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5021                                 break;
5022
5023                                 default:
5024                                 break;
5025
5026                         }
5027                 }
5028                 ndr->flags = _flags_save_UNION;
5029         }
5030         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
5031         return NDR_ERR_SUCCESS;
5032 }
5033
5034 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
5035 {
5036         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
5037         int level;
5038         {
5039                 uint32_t _flags_save_UNION = ndr->flags;
5040                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5041                 level = ndr_pull_get_switch_value(ndr, r);
5042                 if (ndr_flags & NDR_SCALARS) {
5043                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
5044                         switch (level) {
5045                                 case 1: {
5046                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5047                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5048                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5049                                 break; }
5050
5051                                 case 2: {
5052                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5053                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5054                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5055                                 break; }
5056
5057                                 case 3: {
5058                                         NDR_CHECK(ndr_pull_align(ndr, 4));
5059                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5060                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5061                                 break; }
5062
5063                                 case 4: {
5064                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5065                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5066                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5067                                 break; }
5068
5069                                 default: {
5070                                 break; }
5071
5072                         }
5073                 }
5074                 if (ndr_flags & NDR_BUFFERS) {
5075                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5076                         switch (level) {
5077                                 case 1:
5078                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5079                                 break;
5080
5081                                 case 2:
5082                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5083                                 break;
5084
5085                                 case 3:
5086                                 break;
5087
5088                                 case 4:
5089                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5090                                 break;
5091
5092                                 default:
5093                                 break;
5094
5095                         }
5096                 }
5097                 ndr->flags = _flags_save_UNION;
5098         }
5099         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5100         return NDR_ERR_SUCCESS;
5101 }
5102
5103 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5104 {
5105         int level;
5106         {
5107                 uint32_t _flags_save_UNION = ndr->flags;
5108                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5109                 level = ndr_print_get_switch_value(ndr, r);
5110                 ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5111                 switch (level) {
5112                         case 1:
5113                                 ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5114                         break;
5115
5116                         case 2:
5117                                 ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5118                         break;
5119
5120                         case 3:
5121                                 ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5122                         break;
5123
5124                         case 4:
5125                                 ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5126                         break;
5127
5128                         default:
5129                         break;
5130
5131                 }
5132                 ndr->flags = _flags_save_UNION;
5133         }
5134 }
5135
5136 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5137 {
5138         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
5139         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5140 }
5141
5142 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5143 {
5144         if (ndr_flags & NDR_SCALARS) {
5145                 NDR_CHECK(ndr_push_align(ndr, 5));
5146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5147                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5153                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5158                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5159                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5160         }
5161         if (ndr_flags & NDR_BUFFERS) {
5162                 if (r->printer_name) {
5163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5164                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5165                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5166                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5167                 }
5168                 if (r->server_name) {
5169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5173                 }
5174                 if (r->user_name) {
5175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5178                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5179                 }
5180                 if (r->document_name) {
5181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5184                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5185                 }
5186                 if (r->data_type) {
5187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5190                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5191                 }
5192                 if (r->text_status) {
5193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5197                 }
5198         }
5199         return NDR_ERR_SUCCESS;
5200 }
5201
5202 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5203 {
5204         uint32_t _ptr_printer_name;
5205         TALLOC_CTX *_mem_save_printer_name_0;
5206         uint32_t _ptr_server_name;
5207         TALLOC_CTX *_mem_save_server_name_0;
5208         uint32_t _ptr_user_name;
5209         TALLOC_CTX *_mem_save_user_name_0;
5210         uint32_t _ptr_document_name;
5211         TALLOC_CTX *_mem_save_document_name_0;
5212         uint32_t _ptr_data_type;
5213         TALLOC_CTX *_mem_save_data_type_0;
5214         uint32_t _ptr_text_status;
5215         TALLOC_CTX *_mem_save_text_status_0;
5216         if (ndr_flags & NDR_SCALARS) {
5217                 NDR_CHECK(ndr_pull_align(ndr, 5));
5218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5220                 if (_ptr_printer_name) {
5221                         NDR_PULL_ALLOC(ndr, r->printer_name);
5222                 } else {
5223                         r->printer_name = NULL;
5224                 }
5225                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5226                 if (_ptr_server_name) {
5227                         NDR_PULL_ALLOC(ndr, r->server_name);
5228                 } else {
5229                         r->server_name = NULL;
5230                 }
5231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5232                 if (_ptr_user_name) {
5233                         NDR_PULL_ALLOC(ndr, r->user_name);
5234                 } else {
5235                         r->user_name = NULL;
5236                 }
5237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5238                 if (_ptr_document_name) {
5239                         NDR_PULL_ALLOC(ndr, r->document_name);
5240                 } else {
5241                         r->document_name = NULL;
5242                 }
5243                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5244                 if (_ptr_data_type) {
5245                         NDR_PULL_ALLOC(ndr, r->data_type);
5246                 } else {
5247                         r->data_type = NULL;
5248                 }
5249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5250                 if (_ptr_text_status) {
5251                         NDR_PULL_ALLOC(ndr, r->text_status);
5252                 } else {
5253                         r->text_status = NULL;
5254                 }
5255                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5257                 if (r->priority > 99) {
5258                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5259                 }
5260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5263                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5264                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5265         }
5266         if (ndr_flags & NDR_BUFFERS) {
5267                 if (r->printer_name) {
5268                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5269                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5270                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5271                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5272                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5273                                 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));
5274                         }
5275                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5276                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5277                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5278                 }
5279                 if (r->server_name) {
5280                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5281                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5282                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5283                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5284                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5285                                 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));
5286                         }
5287                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5288                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5290                 }
5291                 if (r->user_name) {
5292                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5293                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5294                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5295                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5296                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5297                                 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));
5298                         }
5299                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5300                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5302                 }
5303                 if (r->document_name) {
5304                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5305                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5306                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5307                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5308                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5309                                 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));
5310                         }
5311                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5312                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5313                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5314                 }
5315                 if (r->data_type) {
5316                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5317                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5318                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5319                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5320                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5321                                 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));
5322                         }
5323                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5324                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5326                 }
5327                 if (r->text_status) {
5328                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5329                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5330                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5331                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5332                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5333                                 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));
5334                         }
5335                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5336                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5338                 }
5339         }
5340         return NDR_ERR_SUCCESS;
5341 }
5342
5343 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5344 {
5345         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5346         ndr->depth++;
5347         ndr_print_uint32(ndr, "job_id", r->job_id);
5348         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5349         ndr->depth++;
5350         if (r->printer_name) {
5351                 ndr_print_string(ndr, "printer_name", r->printer_name);
5352         }
5353         ndr->depth--;
5354         ndr_print_ptr(ndr, "server_name", r->server_name);
5355         ndr->depth++;
5356         if (r->server_name) {
5357                 ndr_print_string(ndr, "server_name", r->server_name);
5358         }
5359         ndr->depth--;
5360         ndr_print_ptr(ndr, "user_name", r->user_name);
5361         ndr->depth++;
5362         if (r->user_name) {
5363                 ndr_print_string(ndr, "user_name", r->user_name);
5364         }
5365         ndr->depth--;
5366         ndr_print_ptr(ndr, "document_name", r->document_name);
5367         ndr->depth++;
5368         if (r->document_name) {
5369                 ndr_print_string(ndr, "document_name", r->document_name);
5370         }
5371         ndr->depth--;
5372         ndr_print_ptr(ndr, "data_type", r->data_type);
5373         ndr->depth++;
5374         if (r->data_type) {
5375                 ndr_print_string(ndr, "data_type", r->data_type);
5376         }
5377         ndr->depth--;
5378         ndr_print_ptr(ndr, "text_status", r->text_status);
5379         ndr->depth++;
5380         if (r->text_status) {
5381                 ndr_print_string(ndr, "text_status", r->text_status);
5382         }
5383         ndr->depth--;
5384         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5385         ndr_print_uint32(ndr, "priority", r->priority);
5386         ndr_print_uint32(ndr, "position", r->position);
5387         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5388         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5389         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5390         ndr->depth--;
5391 }
5392
5393 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5394 {
5395         if (ndr_flags & NDR_SCALARS) {
5396                 NDR_CHECK(ndr_push_align(ndr, 5));
5397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5406                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5410                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5417                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5420                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5421         }
5422         if (ndr_flags & NDR_BUFFERS) {
5423                 if (r->printer_name) {
5424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5428                 }
5429                 if (r->server_name) {
5430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5434                 }
5435                 if (r->user_name) {
5436                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5440                 }
5441                 if (r->document_name) {
5442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5444                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5446                 }
5447                 if (r->notify_name) {
5448                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5452                 }
5453                 if (r->data_type) {
5454                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5457                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5458                 }
5459                 if (r->print_processor) {
5460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5461                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5462                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5463                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5464                 }
5465                 if (r->parameters) {
5466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5469                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5470                 }
5471                 if (r->driver_name) {
5472                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5475                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5476                 }
5477                 if (r->text_status) {
5478                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5480                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5481                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5482                 }
5483         }
5484         return NDR_ERR_SUCCESS;
5485 }
5486
5487 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5488 {
5489         uint32_t _ptr_printer_name;
5490         TALLOC_CTX *_mem_save_printer_name_0;
5491         uint32_t _ptr_server_name;
5492         TALLOC_CTX *_mem_save_server_name_0;
5493         uint32_t _ptr_user_name;
5494         TALLOC_CTX *_mem_save_user_name_0;
5495         uint32_t _ptr_document_name;
5496         TALLOC_CTX *_mem_save_document_name_0;
5497         uint32_t _ptr_notify_name;
5498         TALLOC_CTX *_mem_save_notify_name_0;
5499         uint32_t _ptr_data_type;
5500         TALLOC_CTX *_mem_save_data_type_0;
5501         uint32_t _ptr_print_processor;
5502         TALLOC_CTX *_mem_save_print_processor_0;
5503         uint32_t _ptr_parameters;
5504         TALLOC_CTX *_mem_save_parameters_0;
5505         uint32_t _ptr_driver_name;
5506         TALLOC_CTX *_mem_save_driver_name_0;
5507         uint32_t _ptr_text_status;
5508         TALLOC_CTX *_mem_save_text_status_0;
5509         if (ndr_flags & NDR_SCALARS) {
5510                 NDR_CHECK(ndr_pull_align(ndr, 5));
5511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5512                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5513                 if (_ptr_printer_name) {
5514                         NDR_PULL_ALLOC(ndr, r->printer_name);
5515                 } else {
5516                         r->printer_name = NULL;
5517                 }
5518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5519                 if (_ptr_server_name) {
5520                         NDR_PULL_ALLOC(ndr, r->server_name);
5521                 } else {
5522                         r->server_name = NULL;
5523                 }
5524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5525                 if (_ptr_user_name) {
5526                         NDR_PULL_ALLOC(ndr, r->user_name);
5527                 } else {
5528                         r->user_name = NULL;
5529                 }
5530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5531                 if (_ptr_document_name) {
5532                         NDR_PULL_ALLOC(ndr, r->document_name);
5533                 } else {
5534                         r->document_name = NULL;
5535                 }
5536                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5537                 if (_ptr_notify_name) {
5538                         NDR_PULL_ALLOC(ndr, r->notify_name);
5539                 } else {
5540                         r->notify_name = NULL;
5541                 }
5542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5543                 if (_ptr_data_type) {
5544                         NDR_PULL_ALLOC(ndr, r->data_type);
5545                 } else {
5546                         r->data_type = NULL;
5547                 }
5548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5549                 if (_ptr_print_processor) {
5550                         NDR_PULL_ALLOC(ndr, r->print_processor);
5551                 } else {
5552                         r->print_processor = NULL;
5553                 }
5554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5555                 if (_ptr_parameters) {
5556                         NDR_PULL_ALLOC(ndr, r->parameters);
5557                 } else {
5558                         r->parameters = NULL;
5559                 }
5560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5561                 if (_ptr_driver_name) {
5562                         NDR_PULL_ALLOC(ndr, r->driver_name);
5563                 } else {
5564                         r->driver_name = NULL;
5565                 }
5566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5568                 if (_ptr_text_status) {
5569                         NDR_PULL_ALLOC(ndr, r->text_status);
5570                 } else {
5571                         r->text_status = NULL;
5572                 }
5573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5574                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5576                 if (r->priority > 99) {
5577                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5578                 }
5579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5583                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5584                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5587                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5588         }
5589         if (ndr_flags & NDR_BUFFERS) {
5590                 if (r->printer_name) {
5591                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5592                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5593                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5594                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5595                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5596                                 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));
5597                         }
5598                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5599                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5601                 }
5602                 if (r->server_name) {
5603                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5604                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5605                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5606                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5607                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5608                                 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));
5609                         }
5610                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5611                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5612                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5613                 }
5614                 if (r->user_name) {
5615                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5616                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5617                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5618                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5619                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5620                                 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));
5621                         }
5622                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5623                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5625                 }
5626                 if (r->document_name) {
5627                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5628                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5629                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5630                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5631                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5632                                 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));
5633                         }
5634                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5635                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5637                 }
5638                 if (r->notify_name) {
5639                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5640                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5641                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5642                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5643                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5644                                 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));
5645                         }
5646                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5647                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5648                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5649                 }
5650                 if (r->data_type) {
5651                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5652                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5655                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5656                                 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));
5657                         }
5658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5659                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5661                 }
5662                 if (r->print_processor) {
5663                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5664                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5667                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5668                                 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));
5669                         }
5670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5673                 }
5674                 if (r->parameters) {
5675                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5676                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5677                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5678                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5679                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5680                                 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));
5681                         }
5682                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5683                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5685                 }
5686                 if (r->driver_name) {
5687                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5688                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5691                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5692                                 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));
5693                         }
5694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5695                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5697                 }
5698                 if (r->text_status) {
5699                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5700                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5702                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5703                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5704                                 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));
5705                         }
5706                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5707                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5709                 }
5710         }
5711         return NDR_ERR_SUCCESS;
5712 }
5713
5714 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5715 {
5716         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5717         ndr->depth++;
5718         ndr_print_uint32(ndr, "job_id", r->job_id);
5719         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5720         ndr->depth++;
5721         if (r->printer_name) {
5722                 ndr_print_string(ndr, "printer_name", r->printer_name);
5723         }
5724         ndr->depth--;
5725         ndr_print_ptr(ndr, "server_name", r->server_name);
5726         ndr->depth++;
5727         if (r->server_name) {
5728                 ndr_print_string(ndr, "server_name", r->server_name);
5729         }
5730         ndr->depth--;
5731         ndr_print_ptr(ndr, "user_name", r->user_name);
5732         ndr->depth++;
5733         if (r->user_name) {
5734                 ndr_print_string(ndr, "user_name", r->user_name);
5735         }
5736         ndr->depth--;
5737         ndr_print_ptr(ndr, "document_name", r->document_name);
5738         ndr->depth++;
5739         if (r->document_name) {
5740                 ndr_print_string(ndr, "document_name", r->document_name);
5741         }
5742         ndr->depth--;
5743         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5744         ndr->depth++;
5745         if (r->notify_name) {
5746                 ndr_print_string(ndr, "notify_name", r->notify_name);
5747         }
5748         ndr->depth--;
5749         ndr_print_ptr(ndr, "data_type", r->data_type);
5750         ndr->depth++;
5751         if (r->data_type) {
5752                 ndr_print_string(ndr, "data_type", r->data_type);
5753         }
5754         ndr->depth--;
5755         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5756         ndr->depth++;
5757         if (r->print_processor) {
5758                 ndr_print_string(ndr, "print_processor", r->print_processor);
5759         }
5760         ndr->depth--;
5761         ndr_print_ptr(ndr, "parameters", r->parameters);
5762         ndr->depth++;
5763         if (r->parameters) {
5764                 ndr_print_string(ndr, "parameters", r->parameters);
5765         }
5766         ndr->depth--;
5767         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5768         ndr->depth++;
5769         if (r->driver_name) {
5770                 ndr_print_string(ndr, "driver_name", r->driver_name);
5771         }
5772         ndr->depth--;
5773         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5774         ndr_print_ptr(ndr, "text_status", r->text_status);
5775         ndr->depth++;
5776         if (r->text_status) {
5777                 ndr_print_string(ndr, "text_status", r->text_status);
5778         }
5779         ndr->depth--;
5780         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5781         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5782         ndr_print_uint32(ndr, "priority", r->priority);
5783         ndr_print_uint32(ndr, "position", r->position);
5784         ndr_print_uint32(ndr, "start_time", r->start_time);
5785         ndr_print_uint32(ndr, "until_time", r->until_time);
5786         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5787         ndr_print_uint32(ndr, "size", r->size);
5788         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5789         ndr_print_uint32(ndr, "time", r->time);
5790         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5791         ndr->depth--;
5792 }
5793
5794 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5795 {
5796         if (ndr_flags & NDR_SCALARS) {
5797                 NDR_CHECK(ndr_push_align(ndr, 5));
5798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5811                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5818                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5822                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5823         }
5824         if (ndr_flags & NDR_BUFFERS) {
5825                 if (r->printer_name) {
5826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5830                 }
5831                 if (r->server_name) {
5832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5836                 }
5837                 if (r->user_name) {
5838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5842                 }
5843                 if (r->document_name) {
5844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5848                 }
5849                 if (r->notify_name) {
5850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5854                 }
5855                 if (r->data_type) {
5856                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5860                 }
5861                 if (r->print_processor) {
5862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5866                 }
5867                 if (r->parameters) {
5868                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5872                 }
5873                 if (r->driver_name) {
5874                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5875                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5877                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5878                 }
5879                 if (r->text_status) {
5880                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5881                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5883                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5884                 }
5885         }
5886         return NDR_ERR_SUCCESS;
5887 }
5888
5889 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5890 {
5891         uint32_t _ptr_printer_name;
5892         TALLOC_CTX *_mem_save_printer_name_0;
5893         uint32_t _ptr_server_name;
5894         TALLOC_CTX *_mem_save_server_name_0;
5895         uint32_t _ptr_user_name;
5896         TALLOC_CTX *_mem_save_user_name_0;
5897         uint32_t _ptr_document_name;
5898         TALLOC_CTX *_mem_save_document_name_0;
5899         uint32_t _ptr_notify_name;
5900         TALLOC_CTX *_mem_save_notify_name_0;
5901         uint32_t _ptr_data_type;
5902         TALLOC_CTX *_mem_save_data_type_0;
5903         uint32_t _ptr_print_processor;
5904         TALLOC_CTX *_mem_save_print_processor_0;
5905         uint32_t _ptr_parameters;
5906         TALLOC_CTX *_mem_save_parameters_0;
5907         uint32_t _ptr_driver_name;
5908         TALLOC_CTX *_mem_save_driver_name_0;
5909         uint32_t _ptr_text_status;
5910         TALLOC_CTX *_mem_save_text_status_0;
5911         if (ndr_flags & NDR_SCALARS) {
5912                 NDR_CHECK(ndr_pull_align(ndr, 5));
5913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5915                 if (_ptr_printer_name) {
5916                         NDR_PULL_ALLOC(ndr, r->printer_name);
5917                 } else {
5918                         r->printer_name = NULL;
5919                 }
5920                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5921                 if (_ptr_server_name) {
5922                         NDR_PULL_ALLOC(ndr, r->server_name);
5923                 } else {
5924                         r->server_name = NULL;
5925                 }
5926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5927                 if (_ptr_user_name) {
5928                         NDR_PULL_ALLOC(ndr, r->user_name);
5929                 } else {
5930                         r->user_name = NULL;
5931                 }
5932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5933                 if (_ptr_document_name) {
5934                         NDR_PULL_ALLOC(ndr, r->document_name);
5935                 } else {
5936                         r->document_name = NULL;
5937                 }
5938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5939                 if (_ptr_notify_name) {
5940                         NDR_PULL_ALLOC(ndr, r->notify_name);
5941                 } else {
5942                         r->notify_name = NULL;
5943                 }
5944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5945                 if (_ptr_data_type) {
5946                         NDR_PULL_ALLOC(ndr, r->data_type);
5947                 } else {
5948                         r->data_type = NULL;
5949                 }
5950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5951                 if (_ptr_print_processor) {
5952                         NDR_PULL_ALLOC(ndr, r->print_processor);
5953                 } else {
5954                         r->print_processor = NULL;
5955                 }
5956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5957                 if (_ptr_parameters) {
5958                         NDR_PULL_ALLOC(ndr, r->parameters);
5959                 } else {
5960                         r->parameters = NULL;
5961                 }
5962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5963                 if (_ptr_driver_name) {
5964                         NDR_PULL_ALLOC(ndr, r->driver_name);
5965                 } else {
5966                         r->driver_name = NULL;
5967                 }
5968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5970                 if (_ptr_text_status) {
5971                         NDR_PULL_ALLOC(ndr, r->text_status);
5972                 } else {
5973                         r->text_status = NULL;
5974                 }
5975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5976                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5978                 if (r->priority > 99) {
5979                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5980                 }
5981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5986                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5990                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5991         }
5992         if (ndr_flags & NDR_BUFFERS) {
5993                 if (r->printer_name) {
5994                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5995                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5996                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5997                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5998                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5999                                 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));
6000                         }
6001                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
6002                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
6003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
6004                 }
6005                 if (r->server_name) {
6006                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6007                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6010                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6011                                 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));
6012                         }
6013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6014                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6016                 }
6017                 if (r->user_name) {
6018                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6019                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
6020                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
6021                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
6022                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
6023                                 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));
6024                         }
6025                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
6026                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
6027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
6028                 }
6029                 if (r->document_name) {
6030                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6031                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
6032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
6033                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
6034                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
6035                                 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));
6036                         }
6037                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
6038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
6039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
6040                 }
6041                 if (r->notify_name) {
6042                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6043                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
6044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
6045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
6046                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
6047                                 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));
6048                         }
6049                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6050                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6052                 }
6053                 if (r->data_type) {
6054                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6055                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6056                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6057                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6058                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6059                                 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));
6060                         }
6061                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6062                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6063                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6064                 }
6065                 if (r->print_processor) {
6066                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6067                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6070                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6071                                 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));
6072                         }
6073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6076                 }
6077                 if (r->parameters) {
6078                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6079                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6082                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6083                                 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));
6084                         }
6085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6088                 }
6089                 if (r->driver_name) {
6090                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6091                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6092                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6093                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6094                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6095                                 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));
6096                         }
6097                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6098                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6100                 }
6101                 if (r->text_status) {
6102                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6103                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6106                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6107                                 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));
6108                         }
6109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6112                 }
6113         }
6114         return NDR_ERR_SUCCESS;
6115 }
6116
6117 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6118 {
6119         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6120         ndr->depth++;
6121         ndr_print_uint32(ndr, "job_id", r->job_id);
6122         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6123         ndr->depth++;
6124         if (r->printer_name) {
6125                 ndr_print_string(ndr, "printer_name", r->printer_name);
6126         }
6127         ndr->depth--;
6128         ndr_print_ptr(ndr, "server_name", r->server_name);
6129         ndr->depth++;
6130         if (r->server_name) {
6131                 ndr_print_string(ndr, "server_name", r->server_name);
6132         }
6133         ndr->depth--;
6134         ndr_print_ptr(ndr, "user_name", r->user_name);
6135         ndr->depth++;
6136         if (r->user_name) {
6137                 ndr_print_string(ndr, "user_name", r->user_name);
6138         }
6139         ndr->depth--;
6140         ndr_print_ptr(ndr, "document_name", r->document_name);
6141         ndr->depth++;
6142         if (r->document_name) {
6143                 ndr_print_string(ndr, "document_name", r->document_name);
6144         }
6145         ndr->depth--;
6146         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6147         ndr->depth++;
6148         if (r->notify_name) {
6149                 ndr_print_string(ndr, "notify_name", r->notify_name);
6150         }
6151         ndr->depth--;
6152         ndr_print_ptr(ndr, "data_type", r->data_type);
6153         ndr->depth++;
6154         if (r->data_type) {
6155                 ndr_print_string(ndr, "data_type", r->data_type);
6156         }
6157         ndr->depth--;
6158         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6159         ndr->depth++;
6160         if (r->print_processor) {
6161                 ndr_print_string(ndr, "print_processor", r->print_processor);
6162         }
6163         ndr->depth--;
6164         ndr_print_ptr(ndr, "parameters", r->parameters);
6165         ndr->depth++;
6166         if (r->parameters) {
6167                 ndr_print_string(ndr, "parameters", r->parameters);
6168         }
6169         ndr->depth--;
6170         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6171         ndr->depth++;
6172         if (r->driver_name) {
6173                 ndr_print_string(ndr, "driver_name", r->driver_name);
6174         }
6175         ndr->depth--;
6176         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6177         ndr_print_ptr(ndr, "text_status", r->text_status);
6178         ndr->depth++;
6179         if (r->text_status) {
6180                 ndr_print_string(ndr, "text_status", r->text_status);
6181         }
6182         ndr->depth--;
6183         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6184         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6185         ndr_print_uint32(ndr, "priority", r->priority);
6186         ndr_print_uint32(ndr, "position", r->position);
6187         ndr_print_uint32(ndr, "start_time", r->start_time);
6188         ndr_print_uint32(ndr, "until_time", r->until_time);
6189         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6190         ndr_print_uint32(ndr, "size", r->size);
6191         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6192         ndr_print_uint32(ndr, "time", r->time);
6193         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6194         ndr_print_uint32(ndr, "size_high", r->size_high);
6195         ndr->depth--;
6196 }
6197
6198 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6199 {
6200         if (ndr_flags & NDR_SCALARS) {
6201                 int level = ndr_push_get_switch_value(ndr, r);
6202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6203                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6204                 switch (level) {
6205                         case 1: {
6206                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6207                         break; }
6208
6209                         case 2: {
6210                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6211                         break; }
6212
6213                         case 3: {
6214                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6215                         break; }
6216
6217                         case 4: {
6218                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6219                         break; }
6220
6221                         default: {
6222                         break; }
6223
6224                 }
6225         }
6226         if (ndr_flags & NDR_BUFFERS) {
6227                 int level = ndr_push_get_switch_value(ndr, r);
6228                 switch (level) {
6229                         case 1:
6230                                 if (r->info1) {
6231                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6232                                 }
6233                         break;
6234
6235                         case 2:
6236                                 if (r->info2) {
6237                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6238                                 }
6239                         break;
6240
6241                         case 3:
6242                                 if (r->info3) {
6243                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6244                                 }
6245                         break;
6246
6247                         case 4:
6248                                 if (r->info4) {
6249                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6250                                 }
6251                         break;
6252
6253                         default:
6254                         break;
6255
6256                 }
6257         }
6258         return NDR_ERR_SUCCESS;
6259 }
6260
6261 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6262 {
6263         int level;
6264         uint32_t _level;
6265         TALLOC_CTX *_mem_save_info1_0;
6266         TALLOC_CTX *_mem_save_info2_0;
6267         TALLOC_CTX *_mem_save_info3_0;
6268         TALLOC_CTX *_mem_save_info4_0;
6269         level = ndr_pull_get_switch_value(ndr, r);
6270         if (ndr_flags & NDR_SCALARS) {
6271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6272                 if (_level != level) {
6273                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6274                 }
6275                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6276                 switch (level) {
6277                         case 1: {
6278                                 uint32_t _ptr_info1;
6279                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6280                                 if (_ptr_info1) {
6281                                         NDR_PULL_ALLOC(ndr, r->info1);
6282                                 } else {
6283                                         r->info1 = NULL;
6284                                 }
6285                         break; }
6286
6287                         case 2: {
6288                                 uint32_t _ptr_info2;
6289                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6290                                 if (_ptr_info2) {
6291                                         NDR_PULL_ALLOC(ndr, r->info2);
6292                                 } else {
6293                                         r->info2 = NULL;
6294                                 }
6295                         break; }
6296
6297                         case 3: {
6298                                 uint32_t _ptr_info3;
6299                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6300                                 if (_ptr_info3) {
6301                                         NDR_PULL_ALLOC(ndr, r->info3);
6302                                 } else {
6303                                         r->info3 = NULL;
6304                                 }
6305                         break; }
6306
6307                         case 4: {
6308                                 uint32_t _ptr_info4;
6309                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6310                                 if (_ptr_info4) {
6311                                         NDR_PULL_ALLOC(ndr, r->info4);
6312                                 } else {
6313                                         r->info4 = NULL;
6314                                 }
6315                         break; }
6316
6317                         default: {
6318                         break; }
6319
6320                 }
6321         }
6322         if (ndr_flags & NDR_BUFFERS) {
6323                 switch (level) {
6324                         case 1:
6325                                 if (r->info1) {
6326                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6327                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6328                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6329                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6330                                 }
6331                         break;
6332
6333                         case 2:
6334                                 if (r->info2) {
6335                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6336                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6337                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6338                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6339                                 }
6340                         break;
6341
6342                         case 3:
6343                                 if (r->info3) {
6344                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6345                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6346                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6347                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6348                                 }
6349                         break;
6350
6351                         case 4:
6352                                 if (r->info4) {
6353                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6354                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6355                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6356                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6357                                 }
6358                         break;
6359
6360                         default:
6361                         break;
6362
6363                 }
6364         }
6365         return NDR_ERR_SUCCESS;
6366 }
6367
6368 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6369 {
6370         int level;
6371         level = ndr_print_get_switch_value(ndr, r);
6372         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6373         switch (level) {
6374                 case 1:
6375                         ndr_print_ptr(ndr, "info1", r->info1);
6376                         ndr->depth++;
6377                         if (r->info1) {
6378                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6379                         }
6380                         ndr->depth--;
6381                 break;
6382
6383                 case 2:
6384                         ndr_print_ptr(ndr, "info2", r->info2);
6385                         ndr->depth++;
6386                         if (r->info2) {
6387                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6388                         }
6389                         ndr->depth--;
6390                 break;
6391
6392                 case 3:
6393                         ndr_print_ptr(ndr, "info3", r->info3);
6394                         ndr->depth++;
6395                         if (r->info3) {
6396                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6397                         }
6398                         ndr->depth--;
6399                 break;
6400
6401                 case 4:
6402                         ndr_print_ptr(ndr, "info4", r->info4);
6403                         ndr->depth++;
6404                         if (r->info4) {
6405                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6406                         }
6407                         ndr->depth--;
6408                 break;
6409
6410                 default:
6411                 break;
6412
6413         }
6414 }
6415
6416 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6417 {
6418         if (ndr_flags & NDR_SCALARS) {
6419                 NDR_CHECK(ndr_push_align(ndr, 5));
6420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6421                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6422                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6423                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6424         }
6425         if (ndr_flags & NDR_BUFFERS) {
6426                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6427         }
6428         return NDR_ERR_SUCCESS;
6429 }
6430
6431 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6432 {
6433         if (ndr_flags & NDR_SCALARS) {
6434                 NDR_CHECK(ndr_pull_align(ndr, 5));
6435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6436                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6437                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6439         }
6440         if (ndr_flags & NDR_BUFFERS) {
6441                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6442         }
6443         return NDR_ERR_SUCCESS;
6444 }
6445
6446 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6447 {
6448         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6449         ndr->depth++;
6450         ndr_print_uint32(ndr, "level", r->level);
6451         ndr_print_set_switch_value(ndr, &r->info, r->level);
6452         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6453         ndr->depth--;
6454 }
6455
6456 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6457 {
6458         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6459         return NDR_ERR_SUCCESS;
6460 }
6461
6462 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6463 {
6464         uint32_t v;
6465         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6466         *r = v;
6467         return NDR_ERR_SUCCESS;
6468 }
6469
6470 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6471 {
6472         const char *val = NULL;
6473
6474         switch (r) {
6475                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6476                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6477                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6478                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6479                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6480                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6481                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6482                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6483                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6484         }
6485         ndr_print_enum(ndr, name, "ENUM", val, r);
6486 }
6487
6488 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6489 {
6490         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6491         return NDR_ERR_SUCCESS;
6492 }
6493
6494 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6495 {
6496         uint32_t v;
6497         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6498         *r = v;
6499         return NDR_ERR_SUCCESS;
6500 }
6501
6502 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6503 {
6504         const char *val = NULL;
6505
6506         switch (r) {
6507                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6508                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6509                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6510                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6511                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6512         }
6513         ndr_print_enum(ndr, name, "ENUM", val, r);
6514 }
6515
6516 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6517 {
6518         if (ndr_flags & NDR_SCALARS) {
6519                 NDR_CHECK(ndr_push_align(ndr, 5));
6520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6525                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6537                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6540                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6544                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6545                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6549                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6550         }
6551         if (ndr_flags & NDR_BUFFERS) {
6552                 if (r->servername) {
6553                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6554                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6555                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6556                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6557                 }
6558                 if (r->printername) {
6559                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6561                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6562                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6563                 }
6564         }
6565         return NDR_ERR_SUCCESS;
6566 }
6567
6568 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6569 {
6570         uint32_t _ptr_servername;
6571         TALLOC_CTX *_mem_save_servername_0;
6572         uint32_t _ptr_printername;
6573         TALLOC_CTX *_mem_save_printername_0;
6574         if (ndr_flags & NDR_SCALARS) {
6575                 NDR_CHECK(ndr_pull_align(ndr, 5));
6576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6577                 if (_ptr_servername) {
6578                         NDR_PULL_ALLOC(ndr, r->servername);
6579                 } else {
6580                         r->servername = NULL;
6581                 }
6582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6583                 if (_ptr_printername) {
6584                         NDR_PULL_ALLOC(ndr, r->printername);
6585                 } else {
6586                         r->printername = NULL;
6587                 }
6588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6591                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6603                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6606                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6610                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6611                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6615                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6616         }
6617         if (ndr_flags & NDR_BUFFERS) {
6618                 if (r->servername) {
6619                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6620                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6621                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6622                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6623                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6624                                 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));
6625                         }
6626                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6627                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6628                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6629                 }
6630                 if (r->printername) {
6631                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6632                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6633                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6634                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6635                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6636                                 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));
6637                         }
6638                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6639                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6641                 }
6642         }
6643         return NDR_ERR_SUCCESS;
6644 }
6645
6646 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6647 {
6648         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6649         ndr->depth++;
6650         ndr_print_ptr(ndr, "servername", r->servername);
6651         ndr->depth++;
6652         if (r->servername) {
6653                 ndr_print_string(ndr, "servername", r->servername);
6654         }
6655         ndr->depth--;
6656         ndr_print_ptr(ndr, "printername", r->printername);
6657         ndr->depth++;
6658         if (r->printername) {
6659                 ndr_print_string(ndr, "printername", r->printername);
6660         }
6661         ndr->depth--;
6662         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6663         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6664         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6665         ndr_print_spoolss_Time(ndr, "time", &r->time);
6666         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6667         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6668         ndr_print_uint32(ndr, "version", r->version);
6669         ndr_print_uint32(ndr, "free_build", r->free_build);
6670         ndr_print_uint32(ndr, "spooling", r->spooling);
6671         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6672         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6673         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6674         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6675         ndr_print_uint32(ndr, "job_error", r->job_error);
6676         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6677         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6678         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6679         ndr_print_uint32(ndr, "change_id", r->change_id);
6680         ndr_print_WERROR(ndr, "last_error", r->last_error);
6681         ndr_print_uint32(ndr, "status", r->status);
6682         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6683         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6684         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6685         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6686         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6687         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6688         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6689         ndr->depth--;
6690 }
6691
6692 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6693 {
6694         if (ndr_flags & NDR_SCALARS) {
6695                 NDR_CHECK(ndr_push_align(ndr, 5));
6696                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6700                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6701         }
6702         if (ndr_flags & NDR_BUFFERS) {
6703                 if (r->description) {
6704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6707                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6708                 }
6709                 if (r->name) {
6710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6712                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6714                 }
6715                 if (r->comment) {
6716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6720                 }
6721         }
6722         return NDR_ERR_SUCCESS;
6723 }
6724
6725 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6726 {
6727         uint32_t _ptr_description;
6728         TALLOC_CTX *_mem_save_description_0;
6729         uint32_t _ptr_name;
6730         TALLOC_CTX *_mem_save_name_0;
6731         uint32_t _ptr_comment;
6732         TALLOC_CTX *_mem_save_comment_0;
6733         if (ndr_flags & NDR_SCALARS) {
6734                 NDR_CHECK(ndr_pull_align(ndr, 5));
6735                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6737                 if (_ptr_description) {
6738                         NDR_PULL_ALLOC(ndr, r->description);
6739                 } else {
6740                         r->description = NULL;
6741                 }
6742                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6743                 if (_ptr_name) {
6744                         NDR_PULL_ALLOC(ndr, r->name);
6745                 } else {
6746                         r->name = NULL;
6747                 }
6748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6749                 if (_ptr_comment) {
6750                         NDR_PULL_ALLOC(ndr, r->comment);
6751                 } else {
6752                         r->comment = NULL;
6753                 }
6754                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6755         }
6756         if (ndr_flags & NDR_BUFFERS) {
6757                 if (r->description) {
6758                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6759                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6761                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6762                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6763                                 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));
6764                         }
6765                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6766                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6768                 }
6769                 if (r->name) {
6770                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6771                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6773                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6774                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6775                                 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));
6776                         }
6777                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6778                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6780                 }
6781                 if (r->comment) {
6782                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6783                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6785                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6786                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6787                                 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));
6788                         }
6789                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6790                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6792                 }
6793         }
6794         return NDR_ERR_SUCCESS;
6795 }
6796
6797 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6798 {
6799         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6800         ndr->depth++;
6801         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6802         ndr_print_ptr(ndr, "description", r->description);
6803         ndr->depth++;
6804         if (r->description) {
6805                 ndr_print_string(ndr, "description", r->description);
6806         }
6807         ndr->depth--;
6808         ndr_print_ptr(ndr, "name", r->name);
6809         ndr->depth++;
6810         if (r->name) {
6811                 ndr_print_string(ndr, "name", r->name);
6812         }
6813         ndr->depth--;
6814         ndr_print_ptr(ndr, "comment", r->comment);
6815         ndr->depth++;
6816         if (r->comment) {
6817                 ndr_print_string(ndr, "comment", r->comment);
6818         }
6819         ndr->depth--;
6820         ndr->depth--;
6821 }
6822
6823 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6824 {
6825         if (ndr_flags & NDR_SCALARS) {
6826                 NDR_CHECK(ndr_push_align(ndr, 5));
6827                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6828                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6831                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
6835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secdesc_ptr));
6840                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6845                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6848                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6849         }
6850         if (ndr_flags & NDR_BUFFERS) {
6851                 if (r->servername) {
6852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, 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->servername, CH_UTF16)));
6855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6856                 }
6857                 if (r->printername) {
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, 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->printername, CH_UTF16)));
6861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6862                 }
6863                 if (r->sharename) {
6864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, 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->sharename, CH_UTF16)));
6867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6868                 }
6869                 if (r->portname) {
6870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, 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->portname, CH_UTF16)));
6873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6874                 }
6875                 if (r->drivername) {
6876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6878                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6879                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6880                 }
6881                 if (r->comment) {
6882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6883                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6884                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6885                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6886                 }
6887                 if (r->location) {
6888                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6889                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6890                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6891                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6892                 }
6893                 if (r->sepfile) {
6894                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6895                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6896                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6897                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6898                 }
6899                 if (r->printprocessor) {
6900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6904                 }
6905                 if (r->datatype) {
6906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6910                 }
6911                 if (r->parameters) {
6912                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6913                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6915                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6916                 }
6917         }
6918         return NDR_ERR_SUCCESS;
6919 }
6920
6921 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6922 {
6923         uint32_t _ptr_servername;
6924         TALLOC_CTX *_mem_save_servername_0;
6925         uint32_t _ptr_printername;
6926         TALLOC_CTX *_mem_save_printername_0;
6927         uint32_t _ptr_sharename;
6928         TALLOC_CTX *_mem_save_sharename_0;
6929         uint32_t _ptr_portname;
6930         TALLOC_CTX *_mem_save_portname_0;
6931         uint32_t _ptr_drivername;
6932         TALLOC_CTX *_mem_save_drivername_0;
6933         uint32_t _ptr_comment;
6934         TALLOC_CTX *_mem_save_comment_0;
6935         uint32_t _ptr_location;
6936         TALLOC_CTX *_mem_save_location_0;
6937         uint32_t _ptr_sepfile;
6938         TALLOC_CTX *_mem_save_sepfile_0;
6939         uint32_t _ptr_printprocessor;
6940         TALLOC_CTX *_mem_save_printprocessor_0;
6941         uint32_t _ptr_datatype;
6942         TALLOC_CTX *_mem_save_datatype_0;
6943         uint32_t _ptr_parameters;
6944         TALLOC_CTX *_mem_save_parameters_0;
6945         if (ndr_flags & NDR_SCALARS) {
6946                 NDR_CHECK(ndr_pull_align(ndr, 5));
6947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6948                 if (_ptr_servername) {
6949                         NDR_PULL_ALLOC(ndr, r->servername);
6950                 } else {
6951                         r->servername = NULL;
6952                 }
6953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6954                 if (_ptr_printername) {
6955                         NDR_PULL_ALLOC(ndr, r->printername);
6956                 } else {
6957                         r->printername = NULL;
6958                 }
6959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6960                 if (_ptr_sharename) {
6961                         NDR_PULL_ALLOC(ndr, r->sharename);
6962                 } else {
6963                         r->sharename = NULL;
6964                 }
6965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6966                 if (_ptr_portname) {
6967                         NDR_PULL_ALLOC(ndr, r->portname);
6968                 } else {
6969                         r->portname = NULL;
6970                 }
6971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6972                 if (_ptr_drivername) {
6973                         NDR_PULL_ALLOC(ndr, r->drivername);
6974                 } else {
6975                         r->drivername = NULL;
6976                 }
6977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6978                 if (_ptr_comment) {
6979                         NDR_PULL_ALLOC(ndr, r->comment);
6980                 } else {
6981                         r->comment = NULL;
6982                 }
6983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6984                 if (_ptr_location) {
6985                         NDR_PULL_ALLOC(ndr, r->location);
6986                 } else {
6987                         r->location = NULL;
6988                 }
6989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
6990                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6991                 if (_ptr_sepfile) {
6992                         NDR_PULL_ALLOC(ndr, r->sepfile);
6993                 } else {
6994                         r->sepfile = NULL;
6995                 }
6996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6997                 if (_ptr_printprocessor) {
6998                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6999                 } else {
7000                         r->printprocessor = NULL;
7001                 }
7002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
7003                 if (_ptr_datatype) {
7004                         NDR_PULL_ALLOC(ndr, r->datatype);
7005                 } else {
7006                         r->datatype = NULL;
7007                 }
7008                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
7009                 if (_ptr_parameters) {
7010                         NDR_PULL_ALLOC(ndr, r->parameters);
7011                 } else {
7012                         r->parameters = NULL;
7013                 }
7014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secdesc_ptr));
7015                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
7017                 if (r->priority > 99) {
7018                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7019                 }
7020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7023                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7026                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7027         }
7028         if (ndr_flags & NDR_BUFFERS) {
7029                 if (r->servername) {
7030                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7031                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7033                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7034                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7035                                 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));
7036                         }
7037                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7040                 }
7041                 if (r->printername) {
7042                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7043                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7046                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7047                                 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));
7048                         }
7049                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7050                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7052                 }
7053                 if (r->sharename) {
7054                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7055                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7056                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7057                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7058                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7059                                 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));
7060                         }
7061                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7062                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7063                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7064                 }
7065                 if (r->portname) {
7066                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7067                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7070                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7071                                 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));
7072                         }
7073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7076                 }
7077                 if (r->drivername) {
7078                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7079                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7082                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7083                                 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));
7084                         }
7085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7088                 }
7089                 if (r->comment) {
7090                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7091                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7092                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7093                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7094                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7095                                 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));
7096                         }
7097                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7098                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7100                 }
7101                 if (r->location) {
7102                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7103                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7106                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7107                                 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));
7108                         }
7109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7112                 }
7113                 if (r->sepfile) {
7114                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7115                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7118                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7119                                 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));
7120                         }
7121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7124                 }
7125                 if (r->printprocessor) {
7126                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7127                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7130                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7131                                 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));
7132                         }
7133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7136                 }
7137                 if (r->datatype) {
7138                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7139                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7141                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7142                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7143                                 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));
7144                         }
7145                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7146                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7148                 }
7149                 if (r->parameters) {
7150                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7151                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7152                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7153                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7154                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7155                                 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));
7156                         }
7157                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7158                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7160                 }
7161         }
7162         return NDR_ERR_SUCCESS;
7163 }
7164
7165 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7166 {
7167         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7168         ndr->depth++;
7169         ndr_print_ptr(ndr, "servername", r->servername);
7170         ndr->depth++;
7171         if (r->servername) {
7172                 ndr_print_string(ndr, "servername", r->servername);
7173         }
7174         ndr->depth--;
7175         ndr_print_ptr(ndr, "printername", r->printername);
7176         ndr->depth++;
7177         if (r->printername) {
7178                 ndr_print_string(ndr, "printername", r->printername);
7179         }
7180         ndr->depth--;
7181         ndr_print_ptr(ndr, "sharename", r->sharename);
7182         ndr->depth++;
7183         if (r->sharename) {
7184                 ndr_print_string(ndr, "sharename", r->sharename);
7185         }
7186         ndr->depth--;
7187         ndr_print_ptr(ndr, "portname", r->portname);
7188         ndr->depth++;
7189         if (r->portname) {
7190                 ndr_print_string(ndr, "portname", r->portname);
7191         }
7192         ndr->depth--;
7193         ndr_print_ptr(ndr, "drivername", r->drivername);
7194         ndr->depth++;
7195         if (r->drivername) {
7196                 ndr_print_string(ndr, "drivername", r->drivername);
7197         }
7198         ndr->depth--;
7199         ndr_print_ptr(ndr, "comment", r->comment);
7200         ndr->depth++;
7201         if (r->comment) {
7202                 ndr_print_string(ndr, "comment", r->comment);
7203         }
7204         ndr->depth--;
7205         ndr_print_ptr(ndr, "location", r->location);
7206         ndr->depth++;
7207         if (r->location) {
7208                 ndr_print_string(ndr, "location", r->location);
7209         }
7210         ndr->depth--;
7211         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7212         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7213         ndr->depth++;
7214         if (r->sepfile) {
7215                 ndr_print_string(ndr, "sepfile", r->sepfile);
7216         }
7217         ndr->depth--;
7218         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7219         ndr->depth++;
7220         if (r->printprocessor) {
7221                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7222         }
7223         ndr->depth--;
7224         ndr_print_ptr(ndr, "datatype", r->datatype);
7225         ndr->depth++;
7226         if (r->datatype) {
7227                 ndr_print_string(ndr, "datatype", r->datatype);
7228         }
7229         ndr->depth--;
7230         ndr_print_ptr(ndr, "parameters", r->parameters);
7231         ndr->depth++;
7232         if (r->parameters) {
7233                 ndr_print_string(ndr, "parameters", r->parameters);
7234         }
7235         ndr->depth--;
7236         ndr_print_uint32(ndr, "secdesc_ptr", r->secdesc_ptr);
7237         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7238         ndr_print_uint32(ndr, "priority", r->priority);
7239         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7240         ndr_print_uint32(ndr, "starttime", r->starttime);
7241         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7242         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7243         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7244         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7245         ndr->depth--;
7246 }
7247
7248 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7249 {
7250         if (ndr_flags & NDR_SCALARS) {
7251                 NDR_CHECK(ndr_push_align(ndr, 4));
7252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7253                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7254         }
7255         if (ndr_flags & NDR_BUFFERS) {
7256         }
7257         return NDR_ERR_SUCCESS;
7258 }
7259
7260 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7261 {
7262         if (ndr_flags & NDR_SCALARS) {
7263                 NDR_CHECK(ndr_pull_align(ndr, 4));
7264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7265                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7266         }
7267         if (ndr_flags & NDR_BUFFERS) {
7268         }
7269         return NDR_ERR_SUCCESS;
7270 }
7271
7272 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7273 {
7274         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7275         ndr->depth++;
7276         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7277         ndr->depth--;
7278 }
7279
7280 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7281 {
7282         if (ndr_flags & NDR_SCALARS) {
7283                 NDR_CHECK(ndr_push_align(ndr, 5));
7284                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7285                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7286                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7287                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7288         }
7289         if (ndr_flags & NDR_BUFFERS) {
7290                 if (r->printername) {
7291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7294                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7295                 }
7296                 if (r->servername) {
7297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7301                 }
7302         }
7303         return NDR_ERR_SUCCESS;
7304 }
7305
7306 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7307 {
7308         uint32_t _ptr_printername;
7309         TALLOC_CTX *_mem_save_printername_0;
7310         uint32_t _ptr_servername;
7311         TALLOC_CTX *_mem_save_servername_0;
7312         if (ndr_flags & NDR_SCALARS) {
7313                 NDR_CHECK(ndr_pull_align(ndr, 5));
7314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7315                 if (_ptr_printername) {
7316                         NDR_PULL_ALLOC(ndr, r->printername);
7317                 } else {
7318                         r->printername = NULL;
7319                 }
7320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7321                 if (_ptr_servername) {
7322                         NDR_PULL_ALLOC(ndr, r->servername);
7323                 } else {
7324                         r->servername = NULL;
7325                 }
7326                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7327                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7328         }
7329         if (ndr_flags & NDR_BUFFERS) {
7330                 if (r->printername) {
7331                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7332                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7335                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7336                                 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));
7337                         }
7338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7341                 }
7342                 if (r->servername) {
7343                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7344                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7347                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
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->servername), ndr_get_array_length(ndr, &r->servername));
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7353                 }
7354         }
7355         return NDR_ERR_SUCCESS;
7356 }
7357
7358 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7359 {
7360         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7361         ndr->depth++;
7362         ndr_print_ptr(ndr, "printername", r->printername);
7363         ndr->depth++;
7364         if (r->printername) {
7365                 ndr_print_string(ndr, "printername", r->printername);
7366         }
7367         ndr->depth--;
7368         ndr_print_ptr(ndr, "servername", r->servername);
7369         ndr->depth++;
7370         if (r->servername) {
7371                 ndr_print_string(ndr, "servername", r->servername);
7372         }
7373         ndr->depth--;
7374         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7375         ndr->depth--;
7376 }
7377
7378 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7379 {
7380         if (ndr_flags & NDR_SCALARS) {
7381                 NDR_CHECK(ndr_push_align(ndr, 5));
7382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7384                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7387                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7388         }
7389         if (ndr_flags & NDR_BUFFERS) {
7390                 if (r->printername) {
7391                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7395                 }
7396                 if (r->portname) {
7397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7401                 }
7402         }
7403         return NDR_ERR_SUCCESS;
7404 }
7405
7406 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7407 {
7408         uint32_t _ptr_printername;
7409         TALLOC_CTX *_mem_save_printername_0;
7410         uint32_t _ptr_portname;
7411         TALLOC_CTX *_mem_save_portname_0;
7412         if (ndr_flags & NDR_SCALARS) {
7413                 NDR_CHECK(ndr_pull_align(ndr, 5));
7414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7415                 if (_ptr_printername) {
7416                         NDR_PULL_ALLOC(ndr, r->printername);
7417                 } else {
7418                         r->printername = NULL;
7419                 }
7420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7421                 if (_ptr_portname) {
7422                         NDR_PULL_ALLOC(ndr, r->portname);
7423                 } else {
7424                         r->portname = NULL;
7425                 }
7426                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7429                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7430         }
7431         if (ndr_flags & NDR_BUFFERS) {
7432                 if (r->printername) {
7433                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7434                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7437                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7438                                 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));
7439                         }
7440                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7441                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7443                 }
7444                 if (r->portname) {
7445                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7446                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7449                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
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->portname), ndr_get_array_length(ndr, &r->portname));
7451                         }
7452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7455                 }
7456         }
7457         return NDR_ERR_SUCCESS;
7458 }
7459
7460 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7461 {
7462         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7463         ndr->depth++;
7464         ndr_print_ptr(ndr, "printername", r->printername);
7465         ndr->depth++;
7466         if (r->printername) {
7467                 ndr_print_string(ndr, "printername", r->printername);
7468         }
7469         ndr->depth--;
7470         ndr_print_ptr(ndr, "portname", r->portname);
7471         ndr->depth++;
7472         if (r->portname) {
7473                 ndr_print_string(ndr, "portname", r->portname);
7474         }
7475         ndr->depth--;
7476         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7477         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7478         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7479         ndr->depth--;
7480 }
7481
7482 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7483 {
7484         if (ndr_flags & NDR_SCALARS) {
7485                 NDR_CHECK(ndr_push_align(ndr, 4));
7486                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7487                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7488         }
7489         if (ndr_flags & NDR_BUFFERS) {
7490         }
7491         return NDR_ERR_SUCCESS;
7492 }
7493
7494 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7495 {
7496         if (ndr_flags & NDR_SCALARS) {
7497                 NDR_CHECK(ndr_pull_align(ndr, 4));
7498                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7499                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7500         }
7501         if (ndr_flags & NDR_BUFFERS) {
7502         }
7503         return NDR_ERR_SUCCESS;
7504 }
7505
7506 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7507 {
7508         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7509         ndr->depth++;
7510         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7511         ndr->depth--;
7512 }
7513
7514 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7515 {
7516         if (ndr_flags & NDR_SCALARS) {
7517                 NDR_CHECK(ndr_push_align(ndr, 5));
7518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7519                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7520                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7521         }
7522         if (ndr_flags & NDR_BUFFERS) {
7523                 if (r->guid) {
7524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7528                 }
7529         }
7530         return NDR_ERR_SUCCESS;
7531 }
7532
7533 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7534 {
7535         uint32_t _ptr_guid;
7536         TALLOC_CTX *_mem_save_guid_0;
7537         if (ndr_flags & NDR_SCALARS) {
7538                 NDR_CHECK(ndr_pull_align(ndr, 5));
7539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7540                 if (_ptr_guid) {
7541                         NDR_PULL_ALLOC(ndr, r->guid);
7542                 } else {
7543                         r->guid = NULL;
7544                 }
7545                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7546                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7547         }
7548         if (ndr_flags & NDR_BUFFERS) {
7549                 if (r->guid) {
7550                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7551                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7554                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7555                                 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));
7556                         }
7557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7560                 }
7561         }
7562         return NDR_ERR_SUCCESS;
7563 }
7564
7565 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7566 {
7567         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7568         ndr->depth++;
7569         ndr_print_ptr(ndr, "guid", r->guid);
7570         ndr->depth++;
7571         if (r->guid) {
7572                 ndr_print_string(ndr, "guid", r->guid);
7573         }
7574         ndr->depth--;
7575         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7576         ndr->depth--;
7577 }
7578
7579 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo8 *r)
7580 {
7581         if (ndr_flags & NDR_SCALARS) {
7582                 NDR_CHECK(ndr_push_align(ndr, 4));
7583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7584                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7585         }
7586         if (ndr_flags & NDR_BUFFERS) {
7587         }
7588         return NDR_ERR_SUCCESS;
7589 }
7590
7591 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo8 *r)
7592 {
7593         if (ndr_flags & NDR_SCALARS) {
7594                 NDR_CHECK(ndr_pull_align(ndr, 4));
7595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7596                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7597         }
7598         if (ndr_flags & NDR_BUFFERS) {
7599         }
7600         return NDR_ERR_SUCCESS;
7601 }
7602
7603 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo8 *r)
7604 {
7605         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo8");
7606         ndr->depth++;
7607         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7608         ndr->depth--;
7609 }
7610
7611 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo9(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo9 *r)
7612 {
7613         if (ndr_flags & NDR_SCALARS) {
7614                 NDR_CHECK(ndr_push_align(ndr, 4));
7615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7616                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7617         }
7618         if (ndr_flags & NDR_BUFFERS) {
7619         }
7620         return NDR_ERR_SUCCESS;
7621 }
7622
7623 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo9(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo9 *r)
7624 {
7625         if (ndr_flags & NDR_SCALARS) {
7626                 NDR_CHECK(ndr_pull_align(ndr, 4));
7627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7628                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7629         }
7630         if (ndr_flags & NDR_BUFFERS) {
7631         }
7632         return NDR_ERR_SUCCESS;
7633 }
7634
7635 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo9(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo9 *r)
7636 {
7637         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo9");
7638         ndr->depth++;
7639         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7640         ndr->depth--;
7641 }
7642
7643 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7644 {
7645         if (ndr_flags & NDR_SCALARS) {
7646                 int level = ndr_push_get_switch_value(ndr, r);
7647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7648                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7649                 switch (level) {
7650                         case 0: {
7651                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7652                         break; }
7653
7654                         case 1: {
7655                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7656                         break; }
7657
7658                         case 2: {
7659                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7660                         break; }
7661
7662                         case 3: {
7663                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7664                         break; }
7665
7666                         case 4: {
7667                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7668                         break; }
7669
7670                         case 5: {
7671                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7672                         break; }
7673
7674                         case 6: {
7675                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7676                         break; }
7677
7678                         case 7: {
7679                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7680                         break; }
7681
7682                         case 8: {
7683                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7684                         break; }
7685
7686                         case 9: {
7687                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7688                         break; }
7689
7690                         default: {
7691                         break; }
7692
7693                 }
7694         }
7695         if (ndr_flags & NDR_BUFFERS) {
7696                 int level = ndr_push_get_switch_value(ndr, r);
7697                 switch (level) {
7698                         case 0:
7699                                 if (r->info0) {
7700                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7701                                 }
7702                         break;
7703
7704                         case 1:
7705                                 if (r->info1) {
7706                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7707                                 }
7708                         break;
7709
7710                         case 2:
7711                                 if (r->info2) {
7712                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7713                                 }
7714                         break;
7715
7716                         case 3:
7717                                 if (r->info3) {
7718                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7719                                 }
7720                         break;
7721
7722                         case 4:
7723                                 if (r->info4) {
7724                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7725                                 }
7726                         break;
7727
7728                         case 5:
7729                                 if (r->info5) {
7730                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7731                                 }
7732                         break;
7733
7734                         case 6:
7735                                 if (r->info6) {
7736                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7737                                 }
7738                         break;
7739
7740                         case 7:
7741                                 if (r->info7) {
7742                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7743                                 }
7744                         break;
7745
7746                         case 8:
7747                                 if (r->info8) {
7748                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7749                                 }
7750                         break;
7751
7752                         case 9:
7753                                 if (r->info9) {
7754                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7755                                 }
7756                         break;
7757
7758                         default:
7759                         break;
7760
7761                 }
7762         }
7763         return NDR_ERR_SUCCESS;
7764 }
7765
7766 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7767 {
7768         int level;
7769         uint32_t _level;
7770         TALLOC_CTX *_mem_save_info0_0;
7771         TALLOC_CTX *_mem_save_info1_0;
7772         TALLOC_CTX *_mem_save_info2_0;
7773         TALLOC_CTX *_mem_save_info3_0;
7774         TALLOC_CTX *_mem_save_info4_0;
7775         TALLOC_CTX *_mem_save_info5_0;
7776         TALLOC_CTX *_mem_save_info6_0;
7777         TALLOC_CTX *_mem_save_info7_0;
7778         TALLOC_CTX *_mem_save_info8_0;
7779         TALLOC_CTX *_mem_save_info9_0;
7780         level = ndr_pull_get_switch_value(ndr, r);
7781         if (ndr_flags & NDR_SCALARS) {
7782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7783                 if (_level != level) {
7784                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7785                 }
7786                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7787                 switch (level) {
7788                         case 0: {
7789                                 uint32_t _ptr_info0;
7790                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7791                                 if (_ptr_info0) {
7792                                         NDR_PULL_ALLOC(ndr, r->info0);
7793                                 } else {
7794                                         r->info0 = NULL;
7795                                 }
7796                         break; }
7797
7798                         case 1: {
7799                                 uint32_t _ptr_info1;
7800                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7801                                 if (_ptr_info1) {
7802                                         NDR_PULL_ALLOC(ndr, r->info1);
7803                                 } else {
7804                                         r->info1 = NULL;
7805                                 }
7806                         break; }
7807
7808                         case 2: {
7809                                 uint32_t _ptr_info2;
7810                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7811                                 if (_ptr_info2) {
7812                                         NDR_PULL_ALLOC(ndr, r->info2);
7813                                 } else {
7814                                         r->info2 = NULL;
7815                                 }
7816                         break; }
7817
7818                         case 3: {
7819                                 uint32_t _ptr_info3;
7820                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7821                                 if (_ptr_info3) {
7822                                         NDR_PULL_ALLOC(ndr, r->info3);
7823                                 } else {
7824                                         r->info3 = NULL;
7825                                 }
7826                         break; }
7827
7828                         case 4: {
7829                                 uint32_t _ptr_info4;
7830                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7831                                 if (_ptr_info4) {
7832                                         NDR_PULL_ALLOC(ndr, r->info4);
7833                                 } else {
7834                                         r->info4 = NULL;
7835                                 }
7836                         break; }
7837
7838                         case 5: {
7839                                 uint32_t _ptr_info5;
7840                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7841                                 if (_ptr_info5) {
7842                                         NDR_PULL_ALLOC(ndr, r->info5);
7843                                 } else {
7844                                         r->info5 = NULL;
7845                                 }
7846                         break; }
7847
7848                         case 6: {
7849                                 uint32_t _ptr_info6;
7850                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7851                                 if (_ptr_info6) {
7852                                         NDR_PULL_ALLOC(ndr, r->info6);
7853                                 } else {
7854                                         r->info6 = NULL;
7855                                 }
7856                         break; }
7857
7858                         case 7: {
7859                                 uint32_t _ptr_info7;
7860                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7861                                 if (_ptr_info7) {
7862                                         NDR_PULL_ALLOC(ndr, r->info7);
7863                                 } else {
7864                                         r->info7 = NULL;
7865                                 }
7866                         break; }
7867
7868                         case 8: {
7869                                 uint32_t _ptr_info8;
7870                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7871                                 if (_ptr_info8) {
7872                                         NDR_PULL_ALLOC(ndr, r->info8);
7873                                 } else {
7874                                         r->info8 = NULL;
7875                                 }
7876                         break; }
7877
7878                         case 9: {
7879                                 uint32_t _ptr_info9;
7880                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7881                                 if (_ptr_info9) {
7882                                         NDR_PULL_ALLOC(ndr, r->info9);
7883                                 } else {
7884                                         r->info9 = NULL;
7885                                 }
7886                         break; }
7887
7888                         default: {
7889                         break; }
7890
7891                 }
7892         }
7893         if (ndr_flags & NDR_BUFFERS) {
7894                 switch (level) {
7895                         case 0:
7896                                 if (r->info0) {
7897                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7898                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7899                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7900                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7901                                 }
7902                         break;
7903
7904                         case 1:
7905                                 if (r->info1) {
7906                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7907                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7908                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7909                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7910                                 }
7911                         break;
7912
7913                         case 2:
7914                                 if (r->info2) {
7915                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7916                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7917                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7918                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7919                                 }
7920                         break;
7921
7922                         case 3:
7923                                 if (r->info3) {
7924                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7925                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7926                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7927                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7928                                 }
7929                         break;
7930
7931                         case 4:
7932                                 if (r->info4) {
7933                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7934                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7935                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7936                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7937                                 }
7938                         break;
7939
7940                         case 5:
7941                                 if (r->info5) {
7942                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7943                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7944                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7945                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7946                                 }
7947                         break;
7948
7949                         case 6:
7950                                 if (r->info6) {
7951                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7952                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7953                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7954                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7955                                 }
7956                         break;
7957
7958                         case 7:
7959                                 if (r->info7) {
7960                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7961                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7962                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7963                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7964                                 }
7965                         break;
7966
7967                         case 8:
7968                                 if (r->info8) {
7969                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7970                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7971                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7972                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7973                                 }
7974                         break;
7975
7976                         case 9:
7977                                 if (r->info9) {
7978                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7979                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7980                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7981                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7982                                 }
7983                         break;
7984
7985                         default:
7986                         break;
7987
7988                 }
7989         }
7990         return NDR_ERR_SUCCESS;
7991 }
7992
7993 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7994 {
7995         int level;
7996         level = ndr_print_get_switch_value(ndr, r);
7997         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7998         switch (level) {
7999                 case 0:
8000                         ndr_print_ptr(ndr, "info0", r->info0);
8001                         ndr->depth++;
8002                         if (r->info0) {
8003                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
8004                         }
8005                         ndr->depth--;
8006                 break;
8007
8008                 case 1:
8009                         ndr_print_ptr(ndr, "info1", r->info1);
8010                         ndr->depth++;
8011                         if (r->info1) {
8012                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
8013                         }
8014                         ndr->depth--;
8015                 break;
8016
8017                 case 2:
8018                         ndr_print_ptr(ndr, "info2", r->info2);
8019                         ndr->depth++;
8020                         if (r->info2) {
8021                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
8022                         }
8023                         ndr->depth--;
8024                 break;
8025
8026                 case 3:
8027                         ndr_print_ptr(ndr, "info3", r->info3);
8028                         ndr->depth++;
8029                         if (r->info3) {
8030                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
8031                         }
8032                         ndr->depth--;
8033                 break;
8034
8035                 case 4:
8036                         ndr_print_ptr(ndr, "info4", r->info4);
8037                         ndr->depth++;
8038                         if (r->info4) {
8039                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
8040                         }
8041                         ndr->depth--;
8042                 break;
8043
8044                 case 5:
8045                         ndr_print_ptr(ndr, "info5", r->info5);
8046                         ndr->depth++;
8047                         if (r->info5) {
8048                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
8049                         }
8050                         ndr->depth--;
8051                 break;
8052
8053                 case 6:
8054                         ndr_print_ptr(ndr, "info6", r->info6);
8055                         ndr->depth++;
8056                         if (r->info6) {
8057                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8058                         }
8059                         ndr->depth--;
8060                 break;
8061
8062                 case 7:
8063                         ndr_print_ptr(ndr, "info7", r->info7);
8064                         ndr->depth++;
8065                         if (r->info7) {
8066                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8067                         }
8068                         ndr->depth--;
8069                 break;
8070
8071                 case 8:
8072                         ndr_print_ptr(ndr, "info8", r->info8);
8073                         ndr->depth++;
8074                         if (r->info8) {
8075                                 ndr_print_spoolss_SetPrinterInfo8(ndr, "info8", r->info8);
8076                         }
8077                         ndr->depth--;
8078                 break;
8079
8080                 case 9:
8081                         ndr_print_ptr(ndr, "info9", r->info9);
8082                         ndr->depth++;
8083                         if (r->info9) {
8084                                 ndr_print_spoolss_SetPrinterInfo9(ndr, "info9", r->info9);
8085                         }
8086                         ndr->depth--;
8087                 break;
8088
8089                 default:
8090                 break;
8091
8092         }
8093 }
8094
8095 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8096 {
8097         if (ndr_flags & NDR_SCALARS) {
8098                 NDR_CHECK(ndr_push_align(ndr, 5));
8099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8100                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8101                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8102                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8103         }
8104         if (ndr_flags & NDR_BUFFERS) {
8105                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8106         }
8107         return NDR_ERR_SUCCESS;
8108 }
8109
8110 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8111 {
8112         if (ndr_flags & NDR_SCALARS) {
8113                 NDR_CHECK(ndr_pull_align(ndr, 5));
8114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8115                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8116                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8117                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8118         }
8119         if (ndr_flags & NDR_BUFFERS) {
8120                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8121         }
8122         return NDR_ERR_SUCCESS;
8123 }
8124
8125 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8126 {
8127         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8128         ndr->depth++;
8129         ndr_print_uint32(ndr, "level", r->level);
8130         ndr_print_set_switch_value(ndr, &r->info, r->level);
8131         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8132         ndr->depth--;
8133 }
8134
8135 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8136 {
8137         if (ndr_flags & NDR_SCALARS) {
8138                 NDR_CHECK(ndr_push_align(ndr, 4));
8139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8140                 {
8141                         uint32_t _flags_save_string_array = ndr->flags;
8142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8143                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8144                         ndr->flags = _flags_save_string_array;
8145                 }
8146                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8147         }
8148         if (ndr_flags & NDR_BUFFERS) {
8149         }
8150         return NDR_ERR_SUCCESS;
8151 }
8152
8153 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8154 {
8155         if (ndr_flags & NDR_SCALARS) {
8156                 NDR_CHECK(ndr_pull_align(ndr, 4));
8157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8158                 {
8159                         uint32_t _flags_save_string_array = ndr->flags;
8160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8161                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8162                         ndr->flags = _flags_save_string_array;
8163                 }
8164                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8165         }
8166         if (ndr_flags & NDR_BUFFERS) {
8167         }
8168         return NDR_ERR_SUCCESS;
8169 }
8170
8171 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8172 {
8173         ndr_print_struct(ndr, name, "spoolss_StringArray");
8174         ndr->depth++;
8175         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);
8176         ndr_print_string_array(ndr, "string", r->string);
8177         ndr->depth--;
8178 }
8179
8180 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8181 {
8182         if (ndr_flags & NDR_SCALARS) {
8183                 NDR_CHECK(ndr_push_align(ndr, 5));
8184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8185                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8186         }
8187         if (ndr_flags & NDR_BUFFERS) {
8188                 if (r->driver_name) {
8189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8192                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8193                 }
8194         }
8195         return NDR_ERR_SUCCESS;
8196 }
8197
8198 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8199 {
8200         uint32_t _ptr_driver_name;
8201         TALLOC_CTX *_mem_save_driver_name_0;
8202         if (ndr_flags & NDR_SCALARS) {
8203                 NDR_CHECK(ndr_pull_align(ndr, 5));
8204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8205                 if (_ptr_driver_name) {
8206                         NDR_PULL_ALLOC(ndr, r->driver_name);
8207                 } else {
8208                         r->driver_name = NULL;
8209                 }
8210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8211         }
8212         if (ndr_flags & NDR_BUFFERS) {
8213                 if (r->driver_name) {
8214                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8215                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8216                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8217                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8218                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8219                                 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));
8220                         }
8221                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8222                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8223                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8224                 }
8225         }
8226         return NDR_ERR_SUCCESS;
8227 }
8228
8229 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8230 {
8231         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8232         ndr->depth++;
8233         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8234         ndr->depth++;
8235         if (r->driver_name) {
8236                 ndr_print_string(ndr, "driver_name", r->driver_name);
8237         }
8238         ndr->depth--;
8239         ndr->depth--;
8240 }
8241
8242 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8243 {
8244         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8245         return NDR_ERR_SUCCESS;
8246 }
8247
8248 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8249 {
8250         uint32_t v;
8251         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8252         *r = v;
8253         return NDR_ERR_SUCCESS;
8254 }
8255
8256 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8257 {
8258         const char *val = NULL;
8259
8260         switch (r) {
8261                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8262                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8263                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8264                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8265         }
8266         ndr_print_enum(ndr, name, "ENUM", val, r);
8267 }
8268
8269 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8270 {
8271         if (ndr_flags & NDR_SCALARS) {
8272                 NDR_CHECK(ndr_push_align(ndr, 5));
8273                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8274                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8276                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8277                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8278                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8279                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8280         }
8281         if (ndr_flags & NDR_BUFFERS) {
8282                 if (r->driver_name) {
8283                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8286                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8287                 }
8288                 if (r->architecture) {
8289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8293                 }
8294                 if (r->driver_path) {
8295                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8298                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8299                 }
8300                 if (r->data_file) {
8301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8304                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8305                 }
8306                 if (r->config_file) {
8307                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8308                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8310                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8311                 }
8312         }
8313         return NDR_ERR_SUCCESS;
8314 }
8315
8316 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8317 {
8318         uint32_t _ptr_driver_name;
8319         TALLOC_CTX *_mem_save_driver_name_0;
8320         uint32_t _ptr_architecture;
8321         TALLOC_CTX *_mem_save_architecture_0;
8322         uint32_t _ptr_driver_path;
8323         TALLOC_CTX *_mem_save_driver_path_0;
8324         uint32_t _ptr_data_file;
8325         TALLOC_CTX *_mem_save_data_file_0;
8326         uint32_t _ptr_config_file;
8327         TALLOC_CTX *_mem_save_config_file_0;
8328         if (ndr_flags & NDR_SCALARS) {
8329                 NDR_CHECK(ndr_pull_align(ndr, 5));
8330                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8331                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8332                 if (_ptr_driver_name) {
8333                         NDR_PULL_ALLOC(ndr, r->driver_name);
8334                 } else {
8335                         r->driver_name = NULL;
8336                 }
8337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8338                 if (_ptr_architecture) {
8339                         NDR_PULL_ALLOC(ndr, r->architecture);
8340                 } else {
8341                         r->architecture = NULL;
8342                 }
8343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8344                 if (_ptr_driver_path) {
8345                         NDR_PULL_ALLOC(ndr, r->driver_path);
8346                 } else {
8347                         r->driver_path = NULL;
8348                 }
8349                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8350                 if (_ptr_data_file) {
8351                         NDR_PULL_ALLOC(ndr, r->data_file);
8352                 } else {
8353                         r->data_file = NULL;
8354                 }
8355                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8356                 if (_ptr_config_file) {
8357                         NDR_PULL_ALLOC(ndr, r->config_file);
8358                 } else {
8359                         r->config_file = NULL;
8360                 }
8361                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8362         }
8363         if (ndr_flags & NDR_BUFFERS) {
8364                 if (r->driver_name) {
8365                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8366                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8367                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8368                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8369                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8370                                 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));
8371                         }
8372                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8373                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8375                 }
8376                 if (r->architecture) {
8377                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8378                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8379                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8380                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8381                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8382                                 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));
8383                         }
8384                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8385                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8387                 }
8388                 if (r->driver_path) {
8389                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8390                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8391                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8392                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8393                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8394                                 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));
8395                         }
8396                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8397                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8399                 }
8400                 if (r->data_file) {
8401                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8402                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8403                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8404                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8405                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8406                                 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));
8407                         }
8408                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8409                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8411                 }
8412                 if (r->config_file) {
8413                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8414                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8415                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8416                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8417                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8418                                 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));
8419                         }
8420                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8421                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8423                 }
8424         }
8425         return NDR_ERR_SUCCESS;
8426 }
8427
8428 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8429 {
8430         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8431         ndr->depth++;
8432         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8433         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8434         ndr->depth++;
8435         if (r->driver_name) {
8436                 ndr_print_string(ndr, "driver_name", r->driver_name);
8437         }
8438         ndr->depth--;
8439         ndr_print_ptr(ndr, "architecture", r->architecture);
8440         ndr->depth++;
8441         if (r->architecture) {
8442                 ndr_print_string(ndr, "architecture", r->architecture);
8443         }
8444         ndr->depth--;
8445         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8446         ndr->depth++;
8447         if (r->driver_path) {
8448                 ndr_print_string(ndr, "driver_path", r->driver_path);
8449         }
8450         ndr->depth--;
8451         ndr_print_ptr(ndr, "data_file", r->data_file);
8452         ndr->depth++;
8453         if (r->data_file) {
8454                 ndr_print_string(ndr, "data_file", r->data_file);
8455         }
8456         ndr->depth--;
8457         ndr_print_ptr(ndr, "config_file", r->config_file);
8458         ndr->depth++;
8459         if (r->config_file) {
8460                 ndr_print_string(ndr, "config_file", r->config_file);
8461         }
8462         ndr->depth--;
8463         ndr->depth--;
8464 }
8465
8466 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8467 {
8468         if (ndr_flags & NDR_SCALARS) {
8469                 NDR_CHECK(ndr_push_align(ndr, 5));
8470                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8473                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8474                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8476                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8480                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8481                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8482         }
8483         if (ndr_flags & NDR_BUFFERS) {
8484                 if (r->driver_name) {
8485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8486                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8487                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8488                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8489                 }
8490                 if (r->architecture) {
8491                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8492                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8493                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8494                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8495                 }
8496                 if (r->driver_path) {
8497                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8498                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8499                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8500                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8501                 }
8502                 if (r->data_file) {
8503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8506                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8507                 }
8508                 if (r->config_file) {
8509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8513                 }
8514                 if (r->help_file) {
8515                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8516                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8517                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8518                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8519                 }
8520                 if (r->monitor_name) {
8521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8524                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8525                 }
8526                 if (r->default_datatype) {
8527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8530                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8531                 }
8532                 if (r->dependent_files) {
8533                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8534                 }
8535         }
8536         return NDR_ERR_SUCCESS;
8537 }
8538
8539 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8540 {
8541         uint32_t _ptr_driver_name;
8542         TALLOC_CTX *_mem_save_driver_name_0;
8543         uint32_t _ptr_architecture;
8544         TALLOC_CTX *_mem_save_architecture_0;
8545         uint32_t _ptr_driver_path;
8546         TALLOC_CTX *_mem_save_driver_path_0;
8547         uint32_t _ptr_data_file;
8548         TALLOC_CTX *_mem_save_data_file_0;
8549         uint32_t _ptr_config_file;
8550         TALLOC_CTX *_mem_save_config_file_0;
8551         uint32_t _ptr_help_file;
8552         TALLOC_CTX *_mem_save_help_file_0;
8553         uint32_t _ptr_monitor_name;
8554         TALLOC_CTX *_mem_save_monitor_name_0;
8555         uint32_t _ptr_default_datatype;
8556         TALLOC_CTX *_mem_save_default_datatype_0;
8557         uint32_t _ptr_dependent_files;
8558         TALLOC_CTX *_mem_save_dependent_files_0;
8559         if (ndr_flags & NDR_SCALARS) {
8560                 NDR_CHECK(ndr_pull_align(ndr, 5));
8561                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8563                 if (_ptr_driver_name) {
8564                         NDR_PULL_ALLOC(ndr, r->driver_name);
8565                 } else {
8566                         r->driver_name = NULL;
8567                 }
8568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8569                 if (_ptr_architecture) {
8570                         NDR_PULL_ALLOC(ndr, r->architecture);
8571                 } else {
8572                         r->architecture = NULL;
8573                 }
8574                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8575                 if (_ptr_driver_path) {
8576                         NDR_PULL_ALLOC(ndr, r->driver_path);
8577                 } else {
8578                         r->driver_path = NULL;
8579                 }
8580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8581                 if (_ptr_data_file) {
8582                         NDR_PULL_ALLOC(ndr, r->data_file);
8583                 } else {
8584                         r->data_file = NULL;
8585                 }
8586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8587                 if (_ptr_config_file) {
8588                         NDR_PULL_ALLOC(ndr, r->config_file);
8589                 } else {
8590                         r->config_file = NULL;
8591                 }
8592                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8593                 if (_ptr_help_file) {
8594                         NDR_PULL_ALLOC(ndr, r->help_file);
8595                 } else {
8596                         r->help_file = NULL;
8597                 }
8598                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8599                 if (_ptr_monitor_name) {
8600                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8601                 } else {
8602                         r->monitor_name = NULL;
8603                 }
8604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8605                 if (_ptr_default_datatype) {
8606                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8607                 } else {
8608                         r->default_datatype = NULL;
8609                 }
8610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8611                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8612                 if (_ptr_dependent_files) {
8613                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8614                 } else {
8615                         r->dependent_files = NULL;
8616                 }
8617                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8618         }
8619         if (ndr_flags & NDR_BUFFERS) {
8620                 if (r->driver_name) {
8621                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8622                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8623                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8624                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8625                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8626                                 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));
8627                         }
8628                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8629                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8631                 }
8632                 if (r->architecture) {
8633                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8634                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8635                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8636                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8637                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8638                                 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));
8639                         }
8640                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8641                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8643                 }
8644                 if (r->driver_path) {
8645                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8646                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8649                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8650                                 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));
8651                         }
8652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8655                 }
8656                 if (r->data_file) {
8657                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8658                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8659                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8660                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8661                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8662                                 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));
8663                         }
8664                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8665                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8667                 }
8668                 if (r->config_file) {
8669                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8670                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8673                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8674                                 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));
8675                         }
8676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8679                 }
8680                 if (r->help_file) {
8681                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8682                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8683                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8684                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8685                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8686                                 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));
8687                         }
8688                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8689                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8691                 }
8692                 if (r->monitor_name) {
8693                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8694                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8695                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8696                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8697                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8698                                 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));
8699                         }
8700                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8701                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8702                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8703                 }
8704                 if (r->default_datatype) {
8705                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8706                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8707                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8708                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8709                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8710                                 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));
8711                         }
8712                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8713                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8715                 }
8716                 if (r->dependent_files) {
8717                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8718                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8719                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8721                 }
8722         }
8723         return NDR_ERR_SUCCESS;
8724 }
8725
8726 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8727 {
8728         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8729         ndr->depth++;
8730         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8731         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8732         ndr->depth++;
8733         if (r->driver_name) {
8734                 ndr_print_string(ndr, "driver_name", r->driver_name);
8735         }
8736         ndr->depth--;
8737         ndr_print_ptr(ndr, "architecture", r->architecture);
8738         ndr->depth++;
8739         if (r->architecture) {
8740                 ndr_print_string(ndr, "architecture", r->architecture);
8741         }
8742         ndr->depth--;
8743         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8744         ndr->depth++;
8745         if (r->driver_path) {
8746                 ndr_print_string(ndr, "driver_path", r->driver_path);
8747         }
8748         ndr->depth--;
8749         ndr_print_ptr(ndr, "data_file", r->data_file);
8750         ndr->depth++;
8751         if (r->data_file) {
8752                 ndr_print_string(ndr, "data_file", r->data_file);
8753         }
8754         ndr->depth--;
8755         ndr_print_ptr(ndr, "config_file", r->config_file);
8756         ndr->depth++;
8757         if (r->config_file) {
8758                 ndr_print_string(ndr, "config_file", r->config_file);
8759         }
8760         ndr->depth--;
8761         ndr_print_ptr(ndr, "help_file", r->help_file);
8762         ndr->depth++;
8763         if (r->help_file) {
8764                 ndr_print_string(ndr, "help_file", r->help_file);
8765         }
8766         ndr->depth--;
8767         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8768         ndr->depth++;
8769         if (r->monitor_name) {
8770                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8771         }
8772         ndr->depth--;
8773         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8774         ndr->depth++;
8775         if (r->default_datatype) {
8776                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8777         }
8778         ndr->depth--;
8779         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);
8780         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8781         ndr->depth++;
8782         if (r->dependent_files) {
8783                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8784         }
8785         ndr->depth--;
8786         ndr->depth--;
8787 }
8788
8789 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8790 {
8791         if (ndr_flags & NDR_SCALARS) {
8792                 NDR_CHECK(ndr_push_align(ndr, 5));
8793                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8806                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8807         }
8808         if (ndr_flags & NDR_BUFFERS) {
8809                 if (r->driver_name) {
8810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8813                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8814                 }
8815                 if (r->architecture) {
8816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8817                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8819                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8820                 }
8821                 if (r->driver_path) {
8822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8823                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8825                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8826                 }
8827                 if (r->data_file) {
8828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8829                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8831                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8832                 }
8833                 if (r->config_file) {
8834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8835                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8836                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8837                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8838                 }
8839                 if (r->help_file) {
8840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8843                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8844                 }
8845                 if (r->monitor_name) {
8846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8849                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8850                 }
8851                 if (r->default_datatype) {
8852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8856                 }
8857                 if (r->dependent_files) {
8858                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8859                 }
8860                 if (r->previous_names) {
8861                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8862                 }
8863         }
8864         return NDR_ERR_SUCCESS;
8865 }
8866
8867 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8868 {
8869         uint32_t _ptr_driver_name;
8870         TALLOC_CTX *_mem_save_driver_name_0;
8871         uint32_t _ptr_architecture;
8872         TALLOC_CTX *_mem_save_architecture_0;
8873         uint32_t _ptr_driver_path;
8874         TALLOC_CTX *_mem_save_driver_path_0;
8875         uint32_t _ptr_data_file;
8876         TALLOC_CTX *_mem_save_data_file_0;
8877         uint32_t _ptr_config_file;
8878         TALLOC_CTX *_mem_save_config_file_0;
8879         uint32_t _ptr_help_file;
8880         TALLOC_CTX *_mem_save_help_file_0;
8881         uint32_t _ptr_monitor_name;
8882         TALLOC_CTX *_mem_save_monitor_name_0;
8883         uint32_t _ptr_default_datatype;
8884         TALLOC_CTX *_mem_save_default_datatype_0;
8885         uint32_t _ptr_dependent_files;
8886         TALLOC_CTX *_mem_save_dependent_files_0;
8887         uint32_t _ptr_previous_names;
8888         TALLOC_CTX *_mem_save_previous_names_0;
8889         if (ndr_flags & NDR_SCALARS) {
8890                 NDR_CHECK(ndr_pull_align(ndr, 5));
8891                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8893                 if (_ptr_driver_name) {
8894                         NDR_PULL_ALLOC(ndr, r->driver_name);
8895                 } else {
8896                         r->driver_name = NULL;
8897                 }
8898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8899                 if (_ptr_architecture) {
8900                         NDR_PULL_ALLOC(ndr, r->architecture);
8901                 } else {
8902                         r->architecture = NULL;
8903                 }
8904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8905                 if (_ptr_driver_path) {
8906                         NDR_PULL_ALLOC(ndr, r->driver_path);
8907                 } else {
8908                         r->driver_path = NULL;
8909                 }
8910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8911                 if (_ptr_data_file) {
8912                         NDR_PULL_ALLOC(ndr, r->data_file);
8913                 } else {
8914                         r->data_file = NULL;
8915                 }
8916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8917                 if (_ptr_config_file) {
8918                         NDR_PULL_ALLOC(ndr, r->config_file);
8919                 } else {
8920                         r->config_file = NULL;
8921                 }
8922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8923                 if (_ptr_help_file) {
8924                         NDR_PULL_ALLOC(ndr, r->help_file);
8925                 } else {
8926                         r->help_file = NULL;
8927                 }
8928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8929                 if (_ptr_monitor_name) {
8930                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8931                 } else {
8932                         r->monitor_name = NULL;
8933                 }
8934                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8935                 if (_ptr_default_datatype) {
8936                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8937                 } else {
8938                         r->default_datatype = NULL;
8939                 }
8940                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8942                 if (_ptr_dependent_files) {
8943                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8944                 } else {
8945                         r->dependent_files = NULL;
8946                 }
8947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8949                 if (_ptr_previous_names) {
8950                         NDR_PULL_ALLOC(ndr, r->previous_names);
8951                 } else {
8952                         r->previous_names = NULL;
8953                 }
8954                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8955         }
8956         if (ndr_flags & NDR_BUFFERS) {
8957                 if (r->driver_name) {
8958                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8959                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8960                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8961                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8962                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8963                                 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));
8964                         }
8965                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8966                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8967                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8968                 }
8969                 if (r->architecture) {
8970                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8971                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8972                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8973                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8974                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8975                                 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));
8976                         }
8977                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8978                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8979                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8980                 }
8981                 if (r->driver_path) {
8982                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8983                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8984                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8985                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8986                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8987                                 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));
8988                         }
8989                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8990                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8992                 }
8993                 if (r->data_file) {
8994                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8995                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8996                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8997                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8998                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8999                                 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));
9000                         }
9001                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9002                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9004                 }
9005                 if (r->config_file) {
9006                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9007                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9010                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9011                                 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));
9012                         }
9013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9014                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9016                 }
9017                 if (r->help_file) {
9018                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9019                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9020                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9021                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9022                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9023                                 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));
9024                         }
9025                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9026                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9028                 }
9029                 if (r->monitor_name) {
9030                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9031                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9033                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9034                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9035                                 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));
9036                         }
9037                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9040                 }
9041                 if (r->default_datatype) {
9042                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9043                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9046                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9047                                 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));
9048                         }
9049                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9050                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9052                 }
9053                 if (r->dependent_files) {
9054                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9055                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9056                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9057                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9058                 }
9059                 if (r->previous_names) {
9060                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9061                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9062                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9063                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9064                 }
9065         }
9066         return NDR_ERR_SUCCESS;
9067 }
9068
9069 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9070 {
9071         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9072         ndr->depth++;
9073         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9074         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9075         ndr->depth++;
9076         if (r->driver_name) {
9077                 ndr_print_string(ndr, "driver_name", r->driver_name);
9078         }
9079         ndr->depth--;
9080         ndr_print_ptr(ndr, "architecture", r->architecture);
9081         ndr->depth++;
9082         if (r->architecture) {
9083                 ndr_print_string(ndr, "architecture", r->architecture);
9084         }
9085         ndr->depth--;
9086         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9087         ndr->depth++;
9088         if (r->driver_path) {
9089                 ndr_print_string(ndr, "driver_path", r->driver_path);
9090         }
9091         ndr->depth--;
9092         ndr_print_ptr(ndr, "data_file", r->data_file);
9093         ndr->depth++;
9094         if (r->data_file) {
9095                 ndr_print_string(ndr, "data_file", r->data_file);
9096         }
9097         ndr->depth--;
9098         ndr_print_ptr(ndr, "config_file", r->config_file);
9099         ndr->depth++;
9100         if (r->config_file) {
9101                 ndr_print_string(ndr, "config_file", r->config_file);
9102         }
9103         ndr->depth--;
9104         ndr_print_ptr(ndr, "help_file", r->help_file);
9105         ndr->depth++;
9106         if (r->help_file) {
9107                 ndr_print_string(ndr, "help_file", r->help_file);
9108         }
9109         ndr->depth--;
9110         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9111         ndr->depth++;
9112         if (r->monitor_name) {
9113                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9114         }
9115         ndr->depth--;
9116         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9117         ndr->depth++;
9118         if (r->default_datatype) {
9119                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9120         }
9121         ndr->depth--;
9122         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);
9123         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9124         ndr->depth++;
9125         if (r->dependent_files) {
9126                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9127         }
9128         ndr->depth--;
9129         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);
9130         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9131         ndr->depth++;
9132         if (r->previous_names) {
9133                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9134         }
9135         ndr->depth--;
9136         ndr->depth--;
9137 }
9138
9139 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9140 {
9141         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9142         return NDR_ERR_SUCCESS;
9143 }
9144
9145 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9146 {
9147         uint32_t v;
9148         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9149         *r = v;
9150         return NDR_ERR_SUCCESS;
9151 }
9152
9153 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9154 {
9155         ndr_print_uint32(ndr, name, r);
9156         ndr->depth++;
9157         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9158         ndr->depth--;
9159 }
9160
9161 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9162 {
9163         if (ndr_flags & NDR_SCALARS) {
9164                 NDR_CHECK(ndr_push_align(ndr, 8));
9165                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9169                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9170                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9173                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9178                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9179                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9184                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9185         }
9186         if (ndr_flags & NDR_BUFFERS) {
9187                 if (r->driver_name) {
9188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9191                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9192                 }
9193                 if (r->architecture) {
9194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9198                 }
9199                 if (r->driver_path) {
9200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9203                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9204                 }
9205                 if (r->data_file) {
9206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9209                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9210                 }
9211                 if (r->config_file) {
9212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9215                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9216                 }
9217                 if (r->help_file) {
9218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9220                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9221                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9222                 }
9223                 if (r->monitor_name) {
9224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9228                 }
9229                 if (r->default_datatype) {
9230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9233                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9234                 }
9235                 if (r->dependent_files) {
9236                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9237                 }
9238                 if (r->previous_names) {
9239                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9240                 }
9241                 if (r->manufacturer_name) {
9242                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9245                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9246                 }
9247                 if (r->manufacturer_url) {
9248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9252                 }
9253                 if (r->hardware_id) {
9254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9258                 }
9259                 if (r->provider) {
9260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9261                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9262                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9263                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9264                 }
9265         }
9266         return NDR_ERR_SUCCESS;
9267 }
9268
9269 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9270 {
9271         uint32_t _ptr_driver_name;
9272         TALLOC_CTX *_mem_save_driver_name_0;
9273         uint32_t _ptr_architecture;
9274         TALLOC_CTX *_mem_save_architecture_0;
9275         uint32_t _ptr_driver_path;
9276         TALLOC_CTX *_mem_save_driver_path_0;
9277         uint32_t _ptr_data_file;
9278         TALLOC_CTX *_mem_save_data_file_0;
9279         uint32_t _ptr_config_file;
9280         TALLOC_CTX *_mem_save_config_file_0;
9281         uint32_t _ptr_help_file;
9282         TALLOC_CTX *_mem_save_help_file_0;
9283         uint32_t _ptr_monitor_name;
9284         TALLOC_CTX *_mem_save_monitor_name_0;
9285         uint32_t _ptr_default_datatype;
9286         TALLOC_CTX *_mem_save_default_datatype_0;
9287         uint32_t _ptr_dependent_files;
9288         TALLOC_CTX *_mem_save_dependent_files_0;
9289         uint32_t _ptr_previous_names;
9290         TALLOC_CTX *_mem_save_previous_names_0;
9291         uint32_t _ptr_manufacturer_name;
9292         TALLOC_CTX *_mem_save_manufacturer_name_0;
9293         uint32_t _ptr_manufacturer_url;
9294         TALLOC_CTX *_mem_save_manufacturer_url_0;
9295         uint32_t _ptr_hardware_id;
9296         TALLOC_CTX *_mem_save_hardware_id_0;
9297         uint32_t _ptr_provider;
9298         TALLOC_CTX *_mem_save_provider_0;
9299         if (ndr_flags & NDR_SCALARS) {
9300                 NDR_CHECK(ndr_pull_align(ndr, 8));
9301                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9303                 if (_ptr_driver_name) {
9304                         NDR_PULL_ALLOC(ndr, r->driver_name);
9305                 } else {
9306                         r->driver_name = NULL;
9307                 }
9308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9309                 if (_ptr_architecture) {
9310                         NDR_PULL_ALLOC(ndr, r->architecture);
9311                 } else {
9312                         r->architecture = NULL;
9313                 }
9314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9315                 if (_ptr_driver_path) {
9316                         NDR_PULL_ALLOC(ndr, r->driver_path);
9317                 } else {
9318                         r->driver_path = NULL;
9319                 }
9320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9321                 if (_ptr_data_file) {
9322                         NDR_PULL_ALLOC(ndr, r->data_file);
9323                 } else {
9324                         r->data_file = NULL;
9325                 }
9326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9327                 if (_ptr_config_file) {
9328                         NDR_PULL_ALLOC(ndr, r->config_file);
9329                 } else {
9330                         r->config_file = NULL;
9331                 }
9332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9333                 if (_ptr_help_file) {
9334                         NDR_PULL_ALLOC(ndr, r->help_file);
9335                 } else {
9336                         r->help_file = NULL;
9337                 }
9338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9339                 if (_ptr_monitor_name) {
9340                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9341                 } else {
9342                         r->monitor_name = NULL;
9343                 }
9344                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9345                 if (_ptr_default_datatype) {
9346                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9347                 } else {
9348                         r->default_datatype = NULL;
9349                 }
9350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9351                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9352                 if (_ptr_dependent_files) {
9353                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9354                 } else {
9355                         r->dependent_files = NULL;
9356                 }
9357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9358                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9359                 if (_ptr_previous_names) {
9360                         NDR_PULL_ALLOC(ndr, r->previous_names);
9361                 } else {
9362                         r->previous_names = NULL;
9363                 }
9364                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9365                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9367                 if (_ptr_manufacturer_name) {
9368                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9369                 } else {
9370                         r->manufacturer_name = NULL;
9371                 }
9372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9373                 if (_ptr_manufacturer_url) {
9374                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9375                 } else {
9376                         r->manufacturer_url = NULL;
9377                 }
9378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9379                 if (_ptr_hardware_id) {
9380                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9381                 } else {
9382                         r->hardware_id = NULL;
9383                 }
9384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9385                 if (_ptr_provider) {
9386                         NDR_PULL_ALLOC(ndr, r->provider);
9387                 } else {
9388                         r->provider = NULL;
9389                 }
9390                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9391         }
9392         if (ndr_flags & NDR_BUFFERS) {
9393                 if (r->driver_name) {
9394                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9395                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9398                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9399                                 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));
9400                         }
9401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9404                 }
9405                 if (r->architecture) {
9406                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9407                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9408                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9409                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9410                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9411                                 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));
9412                         }
9413                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9414                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9416                 }
9417                 if (r->driver_path) {
9418                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9419                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9421                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9422                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9423                                 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));
9424                         }
9425                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9426                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9428                 }
9429                 if (r->data_file) {
9430                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9431                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9433                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9434                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9435                                 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));
9436                         }
9437                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9438                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9440                 }
9441                 if (r->config_file) {
9442                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9443                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9446                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9447                                 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));
9448                         }
9449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9452                 }
9453                 if (r->help_file) {
9454                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9455                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9456                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9457                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9458                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9459                                 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));
9460                         }
9461                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9462                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9464                 }
9465                 if (r->monitor_name) {
9466                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9467                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9470                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9471                                 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));
9472                         }
9473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9474                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9476                 }
9477                 if (r->default_datatype) {
9478                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9479                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9480                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9481                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9482                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9483                                 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));
9484                         }
9485                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9486                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9488                 }
9489                 if (r->dependent_files) {
9490                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9491                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9492                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9494                 }
9495                 if (r->previous_names) {
9496                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9497                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9498                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9499                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9500                 }
9501                 if (r->manufacturer_name) {
9502                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9503                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9504                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9505                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9506                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9507                                 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));
9508                         }
9509                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9512                 }
9513                 if (r->manufacturer_url) {
9514                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9515                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9516                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9517                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9518                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9519                                 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));
9520                         }
9521                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9524                 }
9525                 if (r->hardware_id) {
9526                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9527                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9530                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9531                                 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));
9532                         }
9533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9536                 }
9537                 if (r->provider) {
9538                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9539                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9542                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9543                                 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));
9544                         }
9545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9548                 }
9549         }
9550         return NDR_ERR_SUCCESS;
9551 }
9552
9553 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9554 {
9555         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9556         ndr->depth++;
9557         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9558         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9559         ndr->depth++;
9560         if (r->driver_name) {
9561                 ndr_print_string(ndr, "driver_name", r->driver_name);
9562         }
9563         ndr->depth--;
9564         ndr_print_ptr(ndr, "architecture", r->architecture);
9565         ndr->depth++;
9566         if (r->architecture) {
9567                 ndr_print_string(ndr, "architecture", r->architecture);
9568         }
9569         ndr->depth--;
9570         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9571         ndr->depth++;
9572         if (r->driver_path) {
9573                 ndr_print_string(ndr, "driver_path", r->driver_path);
9574         }
9575         ndr->depth--;
9576         ndr_print_ptr(ndr, "data_file", r->data_file);
9577         ndr->depth++;
9578         if (r->data_file) {
9579                 ndr_print_string(ndr, "data_file", r->data_file);
9580         }
9581         ndr->depth--;
9582         ndr_print_ptr(ndr, "config_file", r->config_file);
9583         ndr->depth++;
9584         if (r->config_file) {
9585                 ndr_print_string(ndr, "config_file", r->config_file);
9586         }
9587         ndr->depth--;
9588         ndr_print_ptr(ndr, "help_file", r->help_file);
9589         ndr->depth++;
9590         if (r->help_file) {
9591                 ndr_print_string(ndr, "help_file", r->help_file);
9592         }
9593         ndr->depth--;
9594         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9595         ndr->depth++;
9596         if (r->monitor_name) {
9597                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9598         }
9599         ndr->depth--;
9600         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9601         ndr->depth++;
9602         if (r->default_datatype) {
9603                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9604         }
9605         ndr->depth--;
9606         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);
9607         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9608         ndr->depth++;
9609         if (r->dependent_files) {
9610                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9611         }
9612         ndr->depth--;
9613         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);
9614         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9615         ndr->depth++;
9616         if (r->previous_names) {
9617                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9618         }
9619         ndr->depth--;
9620         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9621         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9622         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9623         ndr->depth++;
9624         if (r->manufacturer_name) {
9625                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9626         }
9627         ndr->depth--;
9628         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9629         ndr->depth++;
9630         if (r->manufacturer_url) {
9631                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9632         }
9633         ndr->depth--;
9634         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9635         ndr->depth++;
9636         if (r->hardware_id) {
9637                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9638         }
9639         ndr->depth--;
9640         ndr_print_ptr(ndr, "provider", r->provider);
9641         ndr->depth++;
9642         if (r->provider) {
9643                 ndr_print_string(ndr, "provider", r->provider);
9644         }
9645         ndr->depth--;
9646         ndr->depth--;
9647 }
9648
9649 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9650 {
9651         if (ndr_flags & NDR_SCALARS) {
9652                 NDR_CHECK(ndr_push_align(ndr, 8));
9653                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9656                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9657                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9661                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9666                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9667                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9672                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9680                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9681                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9682                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9683         }
9684         if (ndr_flags & NDR_BUFFERS) {
9685                 if (r->driver_name) {
9686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9689                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9690                 }
9691                 if (r->architecture) {
9692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9696                 }
9697                 if (r->driver_path) {
9698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9701                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9702                 }
9703                 if (r->data_file) {
9704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9707                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9708                 }
9709                 if (r->config_file) {
9710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9712                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9714                 }
9715                 if (r->help_file) {
9716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9720                 }
9721                 if (r->monitor_name) {
9722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9724                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9726                 }
9727                 if (r->default_datatype) {
9728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9732                 }
9733                 if (r->dependent_files) {
9734                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9735                 }
9736                 if (r->previous_names) {
9737                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9738                 }
9739                 if (r->manufacturer_name) {
9740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9744                 }
9745                 if (r->manufacturer_url) {
9746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9747                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9748                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9749                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9750                 }
9751                 if (r->hardware_id) {
9752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9754                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9756                 }
9757                 if (r->provider) {
9758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9762                 }
9763                 if (r->print_processor) {
9764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9768                 }
9769                 if (r->vendor_setup) {
9770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9774                 }
9775                 if (r->color_profiles) {
9776                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9777                 }
9778                 if (r->inf_path) {
9779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9783                 }
9784                 if (r->core_driver_dependencies) {
9785                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9786                 }
9787         }
9788         return NDR_ERR_SUCCESS;
9789 }
9790
9791 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9792 {
9793         uint32_t _ptr_driver_name;
9794         TALLOC_CTX *_mem_save_driver_name_0;
9795         uint32_t _ptr_architecture;
9796         TALLOC_CTX *_mem_save_architecture_0;
9797         uint32_t _ptr_driver_path;
9798         TALLOC_CTX *_mem_save_driver_path_0;
9799         uint32_t _ptr_data_file;
9800         TALLOC_CTX *_mem_save_data_file_0;
9801         uint32_t _ptr_config_file;
9802         TALLOC_CTX *_mem_save_config_file_0;
9803         uint32_t _ptr_help_file;
9804         TALLOC_CTX *_mem_save_help_file_0;
9805         uint32_t _ptr_monitor_name;
9806         TALLOC_CTX *_mem_save_monitor_name_0;
9807         uint32_t _ptr_default_datatype;
9808         TALLOC_CTX *_mem_save_default_datatype_0;
9809         uint32_t _ptr_dependent_files;
9810         TALLOC_CTX *_mem_save_dependent_files_0;
9811         uint32_t _ptr_previous_names;
9812         TALLOC_CTX *_mem_save_previous_names_0;
9813         uint32_t _ptr_manufacturer_name;
9814         TALLOC_CTX *_mem_save_manufacturer_name_0;
9815         uint32_t _ptr_manufacturer_url;
9816         TALLOC_CTX *_mem_save_manufacturer_url_0;
9817         uint32_t _ptr_hardware_id;
9818         TALLOC_CTX *_mem_save_hardware_id_0;
9819         uint32_t _ptr_provider;
9820         TALLOC_CTX *_mem_save_provider_0;
9821         uint32_t _ptr_print_processor;
9822         TALLOC_CTX *_mem_save_print_processor_0;
9823         uint32_t _ptr_vendor_setup;
9824         TALLOC_CTX *_mem_save_vendor_setup_0;
9825         uint32_t _ptr_color_profiles;
9826         TALLOC_CTX *_mem_save_color_profiles_0;
9827         uint32_t _ptr_inf_path;
9828         TALLOC_CTX *_mem_save_inf_path_0;
9829         uint32_t _ptr_core_driver_dependencies;
9830         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9831         if (ndr_flags & NDR_SCALARS) {
9832                 NDR_CHECK(ndr_pull_align(ndr, 8));
9833                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9835                 if (_ptr_driver_name) {
9836                         NDR_PULL_ALLOC(ndr, r->driver_name);
9837                 } else {
9838                         r->driver_name = NULL;
9839                 }
9840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9841                 if (_ptr_architecture) {
9842                         NDR_PULL_ALLOC(ndr, r->architecture);
9843                 } else {
9844                         r->architecture = NULL;
9845                 }
9846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9847                 if (_ptr_driver_path) {
9848                         NDR_PULL_ALLOC(ndr, r->driver_path);
9849                 } else {
9850                         r->driver_path = NULL;
9851                 }
9852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9853                 if (_ptr_data_file) {
9854                         NDR_PULL_ALLOC(ndr, r->data_file);
9855                 } else {
9856                         r->data_file = NULL;
9857                 }
9858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9859                 if (_ptr_config_file) {
9860                         NDR_PULL_ALLOC(ndr, r->config_file);
9861                 } else {
9862                         r->config_file = NULL;
9863                 }
9864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9865                 if (_ptr_help_file) {
9866                         NDR_PULL_ALLOC(ndr, r->help_file);
9867                 } else {
9868                         r->help_file = NULL;
9869                 }
9870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9871                 if (_ptr_monitor_name) {
9872                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9873                 } else {
9874                         r->monitor_name = NULL;
9875                 }
9876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9877                 if (_ptr_default_datatype) {
9878                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9879                 } else {
9880                         r->default_datatype = NULL;
9881                 }
9882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9884                 if (_ptr_dependent_files) {
9885                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9886                 } else {
9887                         r->dependent_files = NULL;
9888                 }
9889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9891                 if (_ptr_previous_names) {
9892                         NDR_PULL_ALLOC(ndr, r->previous_names);
9893                 } else {
9894                         r->previous_names = NULL;
9895                 }
9896                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9897                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9899                 if (_ptr_manufacturer_name) {
9900                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9901                 } else {
9902                         r->manufacturer_name = NULL;
9903                 }
9904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9905                 if (_ptr_manufacturer_url) {
9906                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9907                 } else {
9908                         r->manufacturer_url = NULL;
9909                 }
9910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9911                 if (_ptr_hardware_id) {
9912                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9913                 } else {
9914                         r->hardware_id = NULL;
9915                 }
9916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9917                 if (_ptr_provider) {
9918                         NDR_PULL_ALLOC(ndr, r->provider);
9919                 } else {
9920                         r->provider = NULL;
9921                 }
9922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9923                 if (_ptr_print_processor) {
9924                         NDR_PULL_ALLOC(ndr, r->print_processor);
9925                 } else {
9926                         r->print_processor = NULL;
9927                 }
9928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9929                 if (_ptr_vendor_setup) {
9930                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9931                 } else {
9932                         r->vendor_setup = NULL;
9933                 }
9934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9936                 if (_ptr_color_profiles) {
9937                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9938                 } else {
9939                         r->color_profiles = NULL;
9940                 }
9941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9942                 if (_ptr_inf_path) {
9943                         NDR_PULL_ALLOC(ndr, r->inf_path);
9944                 } else {
9945                         r->inf_path = NULL;
9946                 }
9947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9950                 if (_ptr_core_driver_dependencies) {
9951                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9952                 } else {
9953                         r->core_driver_dependencies = NULL;
9954                 }
9955                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9956                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9957                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9958         }
9959         if (ndr_flags & NDR_BUFFERS) {
9960                 if (r->driver_name) {
9961                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9962                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9965                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9966                                 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));
9967                         }
9968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9971                 }
9972                 if (r->architecture) {
9973                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9974                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9977                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9978                                 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));
9979                         }
9980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9983                 }
9984                 if (r->driver_path) {
9985                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9986                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9987                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9988                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9989                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9990                                 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));
9991                         }
9992                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9993                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9994                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9995                 }
9996                 if (r->data_file) {
9997                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9998                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9999                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
10000                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
10001                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
10002                                 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));
10003                         }
10004                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
10005                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
10006                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10007                 }
10008                 if (r->config_file) {
10009                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10010                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10011                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
10012                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
10013                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
10014                                 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));
10015                         }
10016                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
10017                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
10018                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10019                 }
10020                 if (r->help_file) {
10021                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10022                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10023                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
10024                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
10025                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
10026                                 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));
10027                         }
10028                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
10029                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
10030                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10031                 }
10032                 if (r->monitor_name) {
10033                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10034                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
10036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
10037                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
10038                                 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));
10039                         }
10040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
10041                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
10042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10043                 }
10044                 if (r->default_datatype) {
10045                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10046                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
10048                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
10049                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
10050                                 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));
10051                         }
10052                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10053                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10055                 }
10056                 if (r->dependent_files) {
10057                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10058                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10059                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10061                 }
10062                 if (r->previous_names) {
10063                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10064                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10065                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10067                 }
10068                 if (r->manufacturer_name) {
10069                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10070                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10071                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10072                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10073                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10074                                 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));
10075                         }
10076                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10077                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10079                 }
10080                 if (r->manufacturer_url) {
10081                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10082                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10083                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10084                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10085                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10086                                 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));
10087                         }
10088                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10089                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10091                 }
10092                 if (r->hardware_id) {
10093                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10094                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10095                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10096                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10097                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10098                                 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));
10099                         }
10100                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10101                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10103                 }
10104                 if (r->provider) {
10105                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10106                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10109                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10110                                 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));
10111                         }
10112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10115                 }
10116                 if (r->print_processor) {
10117                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10118                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10121                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10122                                 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));
10123                         }
10124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10127                 }
10128                 if (r->vendor_setup) {
10129                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10130                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10133                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10134                                 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));
10135                         }
10136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10139                 }
10140                 if (r->color_profiles) {
10141                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10142                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10143                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10144                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10145                 }
10146                 if (r->inf_path) {
10147                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10148                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10149                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10150                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10151                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10152                                 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));
10153                         }
10154                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10155                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10157                 }
10158                 if (r->core_driver_dependencies) {
10159                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10160                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10161                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10163                 }
10164         }
10165         return NDR_ERR_SUCCESS;
10166 }
10167
10168 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10169 {
10170         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10171         ndr->depth++;
10172         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10173         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10174         ndr->depth++;
10175         if (r->driver_name) {
10176                 ndr_print_string(ndr, "driver_name", r->driver_name);
10177         }
10178         ndr->depth--;
10179         ndr_print_ptr(ndr, "architecture", r->architecture);
10180         ndr->depth++;
10181         if (r->architecture) {
10182                 ndr_print_string(ndr, "architecture", r->architecture);
10183         }
10184         ndr->depth--;
10185         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10186         ndr->depth++;
10187         if (r->driver_path) {
10188                 ndr_print_string(ndr, "driver_path", r->driver_path);
10189         }
10190         ndr->depth--;
10191         ndr_print_ptr(ndr, "data_file", r->data_file);
10192         ndr->depth++;
10193         if (r->data_file) {
10194                 ndr_print_string(ndr, "data_file", r->data_file);
10195         }
10196         ndr->depth--;
10197         ndr_print_ptr(ndr, "config_file", r->config_file);
10198         ndr->depth++;
10199         if (r->config_file) {
10200                 ndr_print_string(ndr, "config_file", r->config_file);
10201         }
10202         ndr->depth--;
10203         ndr_print_ptr(ndr, "help_file", r->help_file);
10204         ndr->depth++;
10205         if (r->help_file) {
10206                 ndr_print_string(ndr, "help_file", r->help_file);
10207         }
10208         ndr->depth--;
10209         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10210         ndr->depth++;
10211         if (r->monitor_name) {
10212                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10213         }
10214         ndr->depth--;
10215         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10216         ndr->depth++;
10217         if (r->default_datatype) {
10218                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10219         }
10220         ndr->depth--;
10221         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);
10222         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10223         ndr->depth++;
10224         if (r->dependent_files) {
10225                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10226         }
10227         ndr->depth--;
10228         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);
10229         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10230         ndr->depth++;
10231         if (r->previous_names) {
10232                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10233         }
10234         ndr->depth--;
10235         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10236         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10237         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10238         ndr->depth++;
10239         if (r->manufacturer_name) {
10240                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10241         }
10242         ndr->depth--;
10243         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10244         ndr->depth++;
10245         if (r->manufacturer_url) {
10246                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10247         }
10248         ndr->depth--;
10249         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10250         ndr->depth++;
10251         if (r->hardware_id) {
10252                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10253         }
10254         ndr->depth--;
10255         ndr_print_ptr(ndr, "provider", r->provider);
10256         ndr->depth++;
10257         if (r->provider) {
10258                 ndr_print_string(ndr, "provider", r->provider);
10259         }
10260         ndr->depth--;
10261         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10262         ndr->depth++;
10263         if (r->print_processor) {
10264                 ndr_print_string(ndr, "print_processor", r->print_processor);
10265         }
10266         ndr->depth--;
10267         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10268         ndr->depth++;
10269         if (r->vendor_setup) {
10270                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10271         }
10272         ndr->depth--;
10273         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);
10274         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10275         ndr->depth++;
10276         if (r->color_profiles) {
10277                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10278         }
10279         ndr->depth--;
10280         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10281         ndr->depth++;
10282         if (r->inf_path) {
10283                 ndr_print_string(ndr, "inf_path", r->inf_path);
10284         }
10285         ndr->depth--;
10286         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10287         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);
10288         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10289         ndr->depth++;
10290         if (r->core_driver_dependencies) {
10291                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10292         }
10293         ndr->depth--;
10294         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10295         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10296         ndr->depth--;
10297 }
10298
10299 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10300 {
10301         if (ndr_flags & NDR_SCALARS) {
10302                 int level = ndr_push_get_switch_value(ndr, r);
10303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10304                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10305                 switch (level) {
10306                         case 1: {
10307                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10308                         break; }
10309
10310                         case 2: {
10311                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10312                         break; }
10313
10314                         case 3: {
10315                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10316                         break; }
10317
10318                         case 4: {
10319                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10320                         break; }
10321
10322                         case 6: {
10323                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10324                         break; }
10325
10326                         case 8: {
10327                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10328                         break; }
10329
10330                         default:
10331                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10332                 }
10333         }
10334         if (ndr_flags & NDR_BUFFERS) {
10335                 int level = ndr_push_get_switch_value(ndr, r);
10336                 switch (level) {
10337                         case 1:
10338                                 if (r->info1) {
10339                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10340                                 }
10341                         break;
10342
10343                         case 2:
10344                                 if (r->info2) {
10345                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10346                                 }
10347                         break;
10348
10349                         case 3:
10350                                 if (r->info3) {
10351                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10352                                 }
10353                         break;
10354
10355                         case 4:
10356                                 if (r->info4) {
10357                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10358                                 }
10359                         break;
10360
10361                         case 6:
10362                                 if (r->info6) {
10363                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10364                                 }
10365                         break;
10366
10367                         case 8:
10368                                 if (r->info8) {
10369                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10370                                 }
10371                         break;
10372
10373                         default:
10374                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10375                 }
10376         }
10377         return NDR_ERR_SUCCESS;
10378 }
10379
10380 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10381 {
10382         int level;
10383         uint32_t _level;
10384         TALLOC_CTX *_mem_save_info1_0;
10385         TALLOC_CTX *_mem_save_info2_0;
10386         TALLOC_CTX *_mem_save_info3_0;
10387         TALLOC_CTX *_mem_save_info4_0;
10388         TALLOC_CTX *_mem_save_info6_0;
10389         TALLOC_CTX *_mem_save_info8_0;
10390         level = ndr_pull_get_switch_value(ndr, r);
10391         if (ndr_flags & NDR_SCALARS) {
10392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10393                 if (_level != level) {
10394                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10395                 }
10396                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10397                 switch (level) {
10398                         case 1: {
10399                                 uint32_t _ptr_info1;
10400                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10401                                 if (_ptr_info1) {
10402                                         NDR_PULL_ALLOC(ndr, r->info1);
10403                                 } else {
10404                                         r->info1 = NULL;
10405                                 }
10406                         break; }
10407
10408                         case 2: {
10409                                 uint32_t _ptr_info2;
10410                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10411                                 if (_ptr_info2) {
10412                                         NDR_PULL_ALLOC(ndr, r->info2);
10413                                 } else {
10414                                         r->info2 = NULL;
10415                                 }
10416                         break; }
10417
10418                         case 3: {
10419                                 uint32_t _ptr_info3;
10420                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10421                                 if (_ptr_info3) {
10422                                         NDR_PULL_ALLOC(ndr, r->info3);
10423                                 } else {
10424                                         r->info3 = NULL;
10425                                 }
10426                         break; }
10427
10428                         case 4: {
10429                                 uint32_t _ptr_info4;
10430                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10431                                 if (_ptr_info4) {
10432                                         NDR_PULL_ALLOC(ndr, r->info4);
10433                                 } else {
10434                                         r->info4 = NULL;
10435                                 }
10436                         break; }
10437
10438                         case 6: {
10439                                 uint32_t _ptr_info6;
10440                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10441                                 if (_ptr_info6) {
10442                                         NDR_PULL_ALLOC(ndr, r->info6);
10443                                 } else {
10444                                         r->info6 = NULL;
10445                                 }
10446                         break; }
10447
10448                         case 8: {
10449                                 uint32_t _ptr_info8;
10450                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10451                                 if (_ptr_info8) {
10452                                         NDR_PULL_ALLOC(ndr, r->info8);
10453                                 } else {
10454                                         r->info8 = NULL;
10455                                 }
10456                         break; }
10457
10458                         default:
10459                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10460                 }
10461         }
10462         if (ndr_flags & NDR_BUFFERS) {
10463                 switch (level) {
10464                         case 1:
10465                                 if (r->info1) {
10466                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10467                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10468                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10469                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10470                                 }
10471                         break;
10472
10473                         case 2:
10474                                 if (r->info2) {
10475                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10476                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10477                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10478                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10479                                 }
10480                         break;
10481
10482                         case 3:
10483                                 if (r->info3) {
10484                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10485                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10486                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10487                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10488                                 }
10489                         break;
10490
10491                         case 4:
10492                                 if (r->info4) {
10493                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10494                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10495                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10496                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10497                                 }
10498                         break;
10499
10500                         case 6:
10501                                 if (r->info6) {
10502                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10503                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10504                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10505                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10506                                 }
10507                         break;
10508
10509                         case 8:
10510                                 if (r->info8) {
10511                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10512                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10513                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10514                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10515                                 }
10516                         break;
10517
10518                         default:
10519                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10520                 }
10521         }
10522         return NDR_ERR_SUCCESS;
10523 }
10524
10525 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10526 {
10527         int level;
10528         level = ndr_print_get_switch_value(ndr, r);
10529         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10530         switch (level) {
10531                 case 1:
10532                         ndr_print_ptr(ndr, "info1", r->info1);
10533                         ndr->depth++;
10534                         if (r->info1) {
10535                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10536                         }
10537                         ndr->depth--;
10538                 break;
10539
10540                 case 2:
10541                         ndr_print_ptr(ndr, "info2", r->info2);
10542                         ndr->depth++;
10543                         if (r->info2) {
10544                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10545                         }
10546                         ndr->depth--;
10547                 break;
10548
10549                 case 3:
10550                         ndr_print_ptr(ndr, "info3", r->info3);
10551                         ndr->depth++;
10552                         if (r->info3) {
10553                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10554                         }
10555                         ndr->depth--;
10556                 break;
10557
10558                 case 4:
10559                         ndr_print_ptr(ndr, "info4", r->info4);
10560                         ndr->depth++;
10561                         if (r->info4) {
10562                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10563                         }
10564                         ndr->depth--;
10565                 break;
10566
10567                 case 6:
10568                         ndr_print_ptr(ndr, "info6", r->info6);
10569                         ndr->depth++;
10570                         if (r->info6) {
10571                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10572                         }
10573                         ndr->depth--;
10574                 break;
10575
10576                 case 8:
10577                         ndr_print_ptr(ndr, "info8", r->info8);
10578                         ndr->depth++;
10579                         if (r->info8) {
10580                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10581                         }
10582                         ndr->depth--;
10583                 break;
10584
10585                 default:
10586                         ndr_print_bad_level(ndr, name, level);
10587         }
10588 }
10589
10590 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10591 {
10592         if (ndr_flags & NDR_SCALARS) {
10593                 NDR_CHECK(ndr_push_align(ndr, 5));
10594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10595                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10596                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10597                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10598         }
10599         if (ndr_flags & NDR_BUFFERS) {
10600                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10601         }
10602         return NDR_ERR_SUCCESS;
10603 }
10604
10605 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10606 {
10607         if (ndr_flags & NDR_SCALARS) {
10608                 NDR_CHECK(ndr_pull_align(ndr, 5));
10609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10610                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10611                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10612                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10613         }
10614         if (ndr_flags & NDR_BUFFERS) {
10615                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10616         }
10617         return NDR_ERR_SUCCESS;
10618 }
10619
10620 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10621 {
10622         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10623         ndr->depth++;
10624         ndr_print_uint32(ndr, "level", r->level);
10625         ndr_print_set_switch_value(ndr, &r->info, r->level);
10626         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10627         ndr->depth--;
10628 }
10629
10630 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10631 {
10632         if (ndr_flags & NDR_SCALARS) {
10633                 NDR_CHECK(ndr_push_align(ndr, 5));
10634                 {
10635                         uint32_t _flags_save_string = ndr->flags;
10636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10638                         ndr->flags = _flags_save_string;
10639                 }
10640                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10641         }
10642         if (ndr_flags & NDR_BUFFERS) {
10643                 {
10644                         uint32_t _flags_save_string = ndr->flags;
10645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10646                         if (r->driver_name) {
10647                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10648                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10649                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10650                         }
10651                         ndr->flags = _flags_save_string;
10652                 }
10653         }
10654         return NDR_ERR_SUCCESS;
10655 }
10656
10657 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10658 {
10659         uint32_t _ptr_driver_name;
10660         TALLOC_CTX *_mem_save_driver_name_0;
10661         if (ndr_flags & NDR_SCALARS) {
10662                 NDR_CHECK(ndr_pull_align(ndr, 5));
10663                 {
10664                         uint32_t _flags_save_string = ndr->flags;
10665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10666                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10667                         if (_ptr_driver_name) {
10668                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10669                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10670                         } else {
10671                                 r->driver_name = NULL;
10672                         }
10673                         ndr->flags = _flags_save_string;
10674                 }
10675                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10676         }
10677         if (ndr_flags & NDR_BUFFERS) {
10678                 {
10679                         uint32_t _flags_save_string = ndr->flags;
10680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10681                         if (r->driver_name) {
10682                                 uint32_t _relative_save_offset;
10683                                 _relative_save_offset = ndr->offset;
10684                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10685                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10686                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10687                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10688                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10689                                 if (ndr->offset > ndr->relative_highest_offset) {
10690                                         ndr->relative_highest_offset = ndr->offset;
10691                                 }
10692                                 ndr->offset = _relative_save_offset;
10693                         }
10694                         ndr->flags = _flags_save_string;
10695                 }
10696         }
10697         return NDR_ERR_SUCCESS;
10698 }
10699
10700 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10701 {
10702         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10703         ndr->depth++;
10704         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10705         ndr->depth++;
10706         if (r->driver_name) {
10707                 ndr_print_string(ndr, "driver_name", r->driver_name);
10708         }
10709         ndr->depth--;
10710         ndr->depth--;
10711 }
10712
10713 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10714 {
10715         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10716 }
10717
10718 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10719 {
10720         if (ndr_flags & NDR_SCALARS) {
10721                 NDR_CHECK(ndr_push_align(ndr, 5));
10722                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10723                 {
10724                         uint32_t _flags_save_string = ndr->flags;
10725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10726                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10727                         ndr->flags = _flags_save_string;
10728                 }
10729                 {
10730                         uint32_t _flags_save_string = ndr->flags;
10731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10732                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10733                         ndr->flags = _flags_save_string;
10734                 }
10735                 {
10736                         uint32_t _flags_save_string = ndr->flags;
10737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10738                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10739                         ndr->flags = _flags_save_string;
10740                 }
10741                 {
10742                         uint32_t _flags_save_string = ndr->flags;
10743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10745                         ndr->flags = _flags_save_string;
10746                 }
10747                 {
10748                         uint32_t _flags_save_string = ndr->flags;
10749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10751                         ndr->flags = _flags_save_string;
10752                 }
10753                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10754         }
10755         if (ndr_flags & NDR_BUFFERS) {
10756                 {
10757                         uint32_t _flags_save_string = ndr->flags;
10758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10759                         if (r->driver_name) {
10760                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10761                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10762                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10763                         }
10764                         ndr->flags = _flags_save_string;
10765                 }
10766                 {
10767                         uint32_t _flags_save_string = ndr->flags;
10768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10769                         if (r->architecture) {
10770                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
10771                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10772                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
10773                         }
10774                         ndr->flags = _flags_save_string;
10775                 }
10776                 {
10777                         uint32_t _flags_save_string = ndr->flags;
10778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10779                         if (r->driver_path) {
10780                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
10781                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10782                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
10783                         }
10784                         ndr->flags = _flags_save_string;
10785                 }
10786                 {
10787                         uint32_t _flags_save_string = ndr->flags;
10788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10789                         if (r->data_file) {
10790                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
10791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10792                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
10793                         }
10794                         ndr->flags = _flags_save_string;
10795                 }
10796                 {
10797                         uint32_t _flags_save_string = ndr->flags;
10798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10799                         if (r->config_file) {
10800                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
10801                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10802                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
10803                         }
10804                         ndr->flags = _flags_save_string;
10805                 }
10806         }
10807         return NDR_ERR_SUCCESS;
10808 }
10809
10810 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10811 {
10812         uint32_t _ptr_driver_name;
10813         TALLOC_CTX *_mem_save_driver_name_0;
10814         uint32_t _ptr_architecture;
10815         TALLOC_CTX *_mem_save_architecture_0;
10816         uint32_t _ptr_driver_path;
10817         TALLOC_CTX *_mem_save_driver_path_0;
10818         uint32_t _ptr_data_file;
10819         TALLOC_CTX *_mem_save_data_file_0;
10820         uint32_t _ptr_config_file;
10821         TALLOC_CTX *_mem_save_config_file_0;
10822         if (ndr_flags & NDR_SCALARS) {
10823                 NDR_CHECK(ndr_pull_align(ndr, 5));
10824                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10825                 {
10826                         uint32_t _flags_save_string = ndr->flags;
10827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10828                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10829                         if (_ptr_driver_name) {
10830                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10831                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10832                         } else {
10833                                 r->driver_name = NULL;
10834                         }
10835                         ndr->flags = _flags_save_string;
10836                 }
10837                 {
10838                         uint32_t _flags_save_string = ndr->flags;
10839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10840                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10841                         if (_ptr_architecture) {
10842                                 NDR_PULL_ALLOC(ndr, r->architecture);
10843                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10844                         } else {
10845                                 r->architecture = NULL;
10846                         }
10847                         ndr->flags = _flags_save_string;
10848                 }
10849                 {
10850                         uint32_t _flags_save_string = ndr->flags;
10851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10852                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10853                         if (_ptr_driver_path) {
10854                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10855                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10856                         } else {
10857                                 r->driver_path = NULL;
10858                         }
10859                         ndr->flags = _flags_save_string;
10860                 }
10861                 {
10862                         uint32_t _flags_save_string = ndr->flags;
10863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10864                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10865                         if (_ptr_data_file) {
10866                                 NDR_PULL_ALLOC(ndr, r->data_file);
10867                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10868                         } else {
10869                                 r->data_file = NULL;
10870                         }
10871                         ndr->flags = _flags_save_string;
10872                 }
10873                 {
10874                         uint32_t _flags_save_string = ndr->flags;
10875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10877                         if (_ptr_config_file) {
10878                                 NDR_PULL_ALLOC(ndr, r->config_file);
10879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10880                         } else {
10881                                 r->config_file = NULL;
10882                         }
10883                         ndr->flags = _flags_save_string;
10884                 }
10885                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10886         }
10887         if (ndr_flags & NDR_BUFFERS) {
10888                 {
10889                         uint32_t _flags_save_string = ndr->flags;
10890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10891                         if (r->driver_name) {
10892                                 uint32_t _relative_save_offset;
10893                                 _relative_save_offset = ndr->offset;
10894                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10895                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10896                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10897                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10898                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10899                                 if (ndr->offset > ndr->relative_highest_offset) {
10900                                         ndr->relative_highest_offset = ndr->offset;
10901                                 }
10902                                 ndr->offset = _relative_save_offset;
10903                         }
10904                         ndr->flags = _flags_save_string;
10905                 }
10906                 {
10907                         uint32_t _flags_save_string = ndr->flags;
10908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10909                         if (r->architecture) {
10910                                 uint32_t _relative_save_offset;
10911                                 _relative_save_offset = ndr->offset;
10912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10913                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10914                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10915                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10917                                 if (ndr->offset > ndr->relative_highest_offset) {
10918                                         ndr->relative_highest_offset = ndr->offset;
10919                                 }
10920                                 ndr->offset = _relative_save_offset;
10921                         }
10922                         ndr->flags = _flags_save_string;
10923                 }
10924                 {
10925                         uint32_t _flags_save_string = ndr->flags;
10926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10927                         if (r->driver_path) {
10928                                 uint32_t _relative_save_offset;
10929                                 _relative_save_offset = ndr->offset;
10930                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10931                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10932                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10933                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10934                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10935                                 if (ndr->offset > ndr->relative_highest_offset) {
10936                                         ndr->relative_highest_offset = ndr->offset;
10937                                 }
10938                                 ndr->offset = _relative_save_offset;
10939                         }
10940                         ndr->flags = _flags_save_string;
10941                 }
10942                 {
10943                         uint32_t _flags_save_string = ndr->flags;
10944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10945                         if (r->data_file) {
10946                                 uint32_t _relative_save_offset;
10947                                 _relative_save_offset = ndr->offset;
10948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10949                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10950                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10953                                 if (ndr->offset > ndr->relative_highest_offset) {
10954                                         ndr->relative_highest_offset = ndr->offset;
10955                                 }
10956                                 ndr->offset = _relative_save_offset;
10957                         }
10958                         ndr->flags = _flags_save_string;
10959                 }
10960                 {
10961                         uint32_t _flags_save_string = ndr->flags;
10962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10963                         if (r->config_file) {
10964                                 uint32_t _relative_save_offset;
10965                                 _relative_save_offset = ndr->offset;
10966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10967                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10968                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10969                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10971                                 if (ndr->offset > ndr->relative_highest_offset) {
10972                                         ndr->relative_highest_offset = ndr->offset;
10973                                 }
10974                                 ndr->offset = _relative_save_offset;
10975                         }
10976                         ndr->flags = _flags_save_string;
10977                 }
10978         }
10979         return NDR_ERR_SUCCESS;
10980 }
10981
10982 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10983 {
10984         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10985         ndr->depth++;
10986         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10987         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10988         ndr->depth++;
10989         if (r->driver_name) {
10990                 ndr_print_string(ndr, "driver_name", r->driver_name);
10991         }
10992         ndr->depth--;
10993         ndr_print_ptr(ndr, "architecture", r->architecture);
10994         ndr->depth++;
10995         if (r->architecture) {
10996                 ndr_print_string(ndr, "architecture", r->architecture);
10997         }
10998         ndr->depth--;
10999         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11000         ndr->depth++;
11001         if (r->driver_path) {
11002                 ndr_print_string(ndr, "driver_path", r->driver_path);
11003         }
11004         ndr->depth--;
11005         ndr_print_ptr(ndr, "data_file", r->data_file);
11006         ndr->depth++;
11007         if (r->data_file) {
11008                 ndr_print_string(ndr, "data_file", r->data_file);
11009         }
11010         ndr->depth--;
11011         ndr_print_ptr(ndr, "config_file", r->config_file);
11012         ndr->depth++;
11013         if (r->config_file) {
11014                 ndr_print_string(ndr, "config_file", r->config_file);
11015         }
11016         ndr->depth--;
11017         ndr->depth--;
11018 }
11019
11020 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
11021 {
11022         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
11023 }
11024
11025 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
11026 {
11027         if (ndr_flags & NDR_SCALARS) {
11028                 NDR_CHECK(ndr_push_align(ndr, 5));
11029                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11030                 {
11031                         uint32_t _flags_save_string = ndr->flags;
11032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11033                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11034                         ndr->flags = _flags_save_string;
11035                 }
11036                 {
11037                         uint32_t _flags_save_string = ndr->flags;
11038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11039                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11040                         ndr->flags = _flags_save_string;
11041                 }
11042                 {
11043                         uint32_t _flags_save_string = ndr->flags;
11044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11045                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11046                         ndr->flags = _flags_save_string;
11047                 }
11048                 {
11049                         uint32_t _flags_save_string = ndr->flags;
11050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11051                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11052                         ndr->flags = _flags_save_string;
11053                 }
11054                 {
11055                         uint32_t _flags_save_string = ndr->flags;
11056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11057                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11058                         ndr->flags = _flags_save_string;
11059                 }
11060                 {
11061                         uint32_t _flags_save_string = ndr->flags;
11062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11063                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11064                         ndr->flags = _flags_save_string;
11065                 }
11066                 {
11067                         uint32_t _flags_save_string_array = ndr->flags;
11068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11069                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11070                         ndr->flags = _flags_save_string_array;
11071                 }
11072                 {
11073                         uint32_t _flags_save_string = ndr->flags;
11074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11075                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11076                         ndr->flags = _flags_save_string;
11077                 }
11078                 {
11079                         uint32_t _flags_save_string = ndr->flags;
11080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11081                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11082                         ndr->flags = _flags_save_string;
11083                 }
11084                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11085         }
11086         if (ndr_flags & NDR_BUFFERS) {
11087                 {
11088                         uint32_t _flags_save_string = ndr->flags;
11089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11090                         if (r->driver_name) {
11091                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11093                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11094                         }
11095                         ndr->flags = _flags_save_string;
11096                 }
11097                 {
11098                         uint32_t _flags_save_string = ndr->flags;
11099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11100                         if (r->architecture) {
11101                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11103                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11104                         }
11105                         ndr->flags = _flags_save_string;
11106                 }
11107                 {
11108                         uint32_t _flags_save_string = ndr->flags;
11109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11110                         if (r->driver_path) {
11111                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11113                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11114                         }
11115                         ndr->flags = _flags_save_string;
11116                 }
11117                 {
11118                         uint32_t _flags_save_string = ndr->flags;
11119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11120                         if (r->data_file) {
11121                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11122                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11123                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11124                         }
11125                         ndr->flags = _flags_save_string;
11126                 }
11127                 {
11128                         uint32_t _flags_save_string = ndr->flags;
11129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11130                         if (r->config_file) {
11131                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11132                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11133                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11134                         }
11135                         ndr->flags = _flags_save_string;
11136                 }
11137                 {
11138                         uint32_t _flags_save_string = ndr->flags;
11139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11140                         if (r->help_file) {
11141                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11142                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11143                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11144                         }
11145                         ndr->flags = _flags_save_string;
11146                 }
11147                 {
11148                         uint32_t _flags_save_string_array = ndr->flags;
11149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11150                         if (r->dependent_files) {
11151                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11152                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11153                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11154                         }
11155                         ndr->flags = _flags_save_string_array;
11156                 }
11157                 {
11158                         uint32_t _flags_save_string = ndr->flags;
11159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11160                         if (r->monitor_name) {
11161                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11162                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11163                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11164                         }
11165                         ndr->flags = _flags_save_string;
11166                 }
11167                 {
11168                         uint32_t _flags_save_string = ndr->flags;
11169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11170                         if (r->default_datatype) {
11171                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11172                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11173                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11174                         }
11175                         ndr->flags = _flags_save_string;
11176                 }
11177         }
11178         return NDR_ERR_SUCCESS;
11179 }
11180
11181 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11182 {
11183         uint32_t _ptr_driver_name;
11184         TALLOC_CTX *_mem_save_driver_name_0;
11185         uint32_t _ptr_architecture;
11186         TALLOC_CTX *_mem_save_architecture_0;
11187         uint32_t _ptr_driver_path;
11188         TALLOC_CTX *_mem_save_driver_path_0;
11189         uint32_t _ptr_data_file;
11190         TALLOC_CTX *_mem_save_data_file_0;
11191         uint32_t _ptr_config_file;
11192         TALLOC_CTX *_mem_save_config_file_0;
11193         uint32_t _ptr_help_file;
11194         TALLOC_CTX *_mem_save_help_file_0;
11195         uint32_t _ptr_dependent_files;
11196         TALLOC_CTX *_mem_save_dependent_files_0;
11197         uint32_t _ptr_monitor_name;
11198         TALLOC_CTX *_mem_save_monitor_name_0;
11199         uint32_t _ptr_default_datatype;
11200         TALLOC_CTX *_mem_save_default_datatype_0;
11201         if (ndr_flags & NDR_SCALARS) {
11202                 NDR_CHECK(ndr_pull_align(ndr, 5));
11203                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11204                 {
11205                         uint32_t _flags_save_string = ndr->flags;
11206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11207                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11208                         if (_ptr_driver_name) {
11209                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11210                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11211                         } else {
11212                                 r->driver_name = NULL;
11213                         }
11214                         ndr->flags = _flags_save_string;
11215                 }
11216                 {
11217                         uint32_t _flags_save_string = ndr->flags;
11218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11220                         if (_ptr_architecture) {
11221                                 NDR_PULL_ALLOC(ndr, r->architecture);
11222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11223                         } else {
11224                                 r->architecture = NULL;
11225                         }
11226                         ndr->flags = _flags_save_string;
11227                 }
11228                 {
11229                         uint32_t _flags_save_string = ndr->flags;
11230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11231                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11232                         if (_ptr_driver_path) {
11233                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11234                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11235                         } else {
11236                                 r->driver_path = NULL;
11237                         }
11238                         ndr->flags = _flags_save_string;
11239                 }
11240                 {
11241                         uint32_t _flags_save_string = ndr->flags;
11242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11243                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11244                         if (_ptr_data_file) {
11245                                 NDR_PULL_ALLOC(ndr, r->data_file);
11246                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11247                         } else {
11248                                 r->data_file = NULL;
11249                         }
11250                         ndr->flags = _flags_save_string;
11251                 }
11252                 {
11253                         uint32_t _flags_save_string = ndr->flags;
11254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11255                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11256                         if (_ptr_config_file) {
11257                                 NDR_PULL_ALLOC(ndr, r->config_file);
11258                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11259                         } else {
11260                                 r->config_file = NULL;
11261                         }
11262                         ndr->flags = _flags_save_string;
11263                 }
11264                 {
11265                         uint32_t _flags_save_string = ndr->flags;
11266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11267                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11268                         if (_ptr_help_file) {
11269                                 NDR_PULL_ALLOC(ndr, r->help_file);
11270                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11271                         } else {
11272                                 r->help_file = NULL;
11273                         }
11274                         ndr->flags = _flags_save_string;
11275                 }
11276                 {
11277                         uint32_t _flags_save_string_array = ndr->flags;
11278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11279                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11280                         if (_ptr_dependent_files) {
11281                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11282                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11283                         } else {
11284                                 r->dependent_files = NULL;
11285                         }
11286                         ndr->flags = _flags_save_string_array;
11287                 }
11288                 {
11289                         uint32_t _flags_save_string = ndr->flags;
11290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11291                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11292                         if (_ptr_monitor_name) {
11293                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11294                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11295                         } else {
11296                                 r->monitor_name = NULL;
11297                         }
11298                         ndr->flags = _flags_save_string;
11299                 }
11300                 {
11301                         uint32_t _flags_save_string = ndr->flags;
11302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11303                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11304                         if (_ptr_default_datatype) {
11305                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11306                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11307                         } else {
11308                                 r->default_datatype = NULL;
11309                         }
11310                         ndr->flags = _flags_save_string;
11311                 }
11312                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11313         }
11314         if (ndr_flags & NDR_BUFFERS) {
11315                 {
11316                         uint32_t _flags_save_string = ndr->flags;
11317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11318                         if (r->driver_name) {
11319                                 uint32_t _relative_save_offset;
11320                                 _relative_save_offset = ndr->offset;
11321                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11322                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11323                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11324                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11325                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11326                                 if (ndr->offset > ndr->relative_highest_offset) {
11327                                         ndr->relative_highest_offset = ndr->offset;
11328                                 }
11329                                 ndr->offset = _relative_save_offset;
11330                         }
11331                         ndr->flags = _flags_save_string;
11332                 }
11333                 {
11334                         uint32_t _flags_save_string = ndr->flags;
11335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11336                         if (r->architecture) {
11337                                 uint32_t _relative_save_offset;
11338                                 _relative_save_offset = ndr->offset;
11339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11340                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11341                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11344                                 if (ndr->offset > ndr->relative_highest_offset) {
11345                                         ndr->relative_highest_offset = ndr->offset;
11346                                 }
11347                                 ndr->offset = _relative_save_offset;
11348                         }
11349                         ndr->flags = _flags_save_string;
11350                 }
11351                 {
11352                         uint32_t _flags_save_string = ndr->flags;
11353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11354                         if (r->driver_path) {
11355                                 uint32_t _relative_save_offset;
11356                                 _relative_save_offset = ndr->offset;
11357                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11358                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11359                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11360                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11361                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11362                                 if (ndr->offset > ndr->relative_highest_offset) {
11363                                         ndr->relative_highest_offset = ndr->offset;
11364                                 }
11365                                 ndr->offset = _relative_save_offset;
11366                         }
11367                         ndr->flags = _flags_save_string;
11368                 }
11369                 {
11370                         uint32_t _flags_save_string = ndr->flags;
11371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11372                         if (r->data_file) {
11373                                 uint32_t _relative_save_offset;
11374                                 _relative_save_offset = ndr->offset;
11375                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11376                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11377                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11378                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11379                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11380                                 if (ndr->offset > ndr->relative_highest_offset) {
11381                                         ndr->relative_highest_offset = ndr->offset;
11382                                 }
11383                                 ndr->offset = _relative_save_offset;
11384                         }
11385                         ndr->flags = _flags_save_string;
11386                 }
11387                 {
11388                         uint32_t _flags_save_string = ndr->flags;
11389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11390                         if (r->config_file) {
11391                                 uint32_t _relative_save_offset;
11392                                 _relative_save_offset = ndr->offset;
11393                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11394                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11395                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11396                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11397                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11398                                 if (ndr->offset > ndr->relative_highest_offset) {
11399                                         ndr->relative_highest_offset = ndr->offset;
11400                                 }
11401                                 ndr->offset = _relative_save_offset;
11402                         }
11403                         ndr->flags = _flags_save_string;
11404                 }
11405                 {
11406                         uint32_t _flags_save_string = ndr->flags;
11407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11408                         if (r->help_file) {
11409                                 uint32_t _relative_save_offset;
11410                                 _relative_save_offset = ndr->offset;
11411                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11412                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11413                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11414                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11415                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11416                                 if (ndr->offset > ndr->relative_highest_offset) {
11417                                         ndr->relative_highest_offset = ndr->offset;
11418                                 }
11419                                 ndr->offset = _relative_save_offset;
11420                         }
11421                         ndr->flags = _flags_save_string;
11422                 }
11423                 {
11424                         uint32_t _flags_save_string_array = ndr->flags;
11425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11426                         if (r->dependent_files) {
11427                                 uint32_t _relative_save_offset;
11428                                 _relative_save_offset = ndr->offset;
11429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11430                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11431                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11432                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11434                                 if (ndr->offset > ndr->relative_highest_offset) {
11435                                         ndr->relative_highest_offset = ndr->offset;
11436                                 }
11437                                 ndr->offset = _relative_save_offset;
11438                         }
11439                         ndr->flags = _flags_save_string_array;
11440                 }
11441                 {
11442                         uint32_t _flags_save_string = ndr->flags;
11443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11444                         if (r->monitor_name) {
11445                                 uint32_t _relative_save_offset;
11446                                 _relative_save_offset = ndr->offset;
11447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11448                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11449                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11452                                 if (ndr->offset > ndr->relative_highest_offset) {
11453                                         ndr->relative_highest_offset = ndr->offset;
11454                                 }
11455                                 ndr->offset = _relative_save_offset;
11456                         }
11457                         ndr->flags = _flags_save_string;
11458                 }
11459                 {
11460                         uint32_t _flags_save_string = ndr->flags;
11461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11462                         if (r->default_datatype) {
11463                                 uint32_t _relative_save_offset;
11464                                 _relative_save_offset = ndr->offset;
11465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11466                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11467                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11470                                 if (ndr->offset > ndr->relative_highest_offset) {
11471                                         ndr->relative_highest_offset = ndr->offset;
11472                                 }
11473                                 ndr->offset = _relative_save_offset;
11474                         }
11475                         ndr->flags = _flags_save_string;
11476                 }
11477         }
11478         return NDR_ERR_SUCCESS;
11479 }
11480
11481 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11482 {
11483         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11484         ndr->depth++;
11485         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11486         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11487         ndr->depth++;
11488         if (r->driver_name) {
11489                 ndr_print_string(ndr, "driver_name", r->driver_name);
11490         }
11491         ndr->depth--;
11492         ndr_print_ptr(ndr, "architecture", r->architecture);
11493         ndr->depth++;
11494         if (r->architecture) {
11495                 ndr_print_string(ndr, "architecture", r->architecture);
11496         }
11497         ndr->depth--;
11498         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11499         ndr->depth++;
11500         if (r->driver_path) {
11501                 ndr_print_string(ndr, "driver_path", r->driver_path);
11502         }
11503         ndr->depth--;
11504         ndr_print_ptr(ndr, "data_file", r->data_file);
11505         ndr->depth++;
11506         if (r->data_file) {
11507                 ndr_print_string(ndr, "data_file", r->data_file);
11508         }
11509         ndr->depth--;
11510         ndr_print_ptr(ndr, "config_file", r->config_file);
11511         ndr->depth++;
11512         if (r->config_file) {
11513                 ndr_print_string(ndr, "config_file", r->config_file);
11514         }
11515         ndr->depth--;
11516         ndr_print_ptr(ndr, "help_file", r->help_file);
11517         ndr->depth++;
11518         if (r->help_file) {
11519                 ndr_print_string(ndr, "help_file", r->help_file);
11520         }
11521         ndr->depth--;
11522         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11523         ndr->depth++;
11524         if (r->dependent_files) {
11525                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11526         }
11527         ndr->depth--;
11528         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11529         ndr->depth++;
11530         if (r->monitor_name) {
11531                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11532         }
11533         ndr->depth--;
11534         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11535         ndr->depth++;
11536         if (r->default_datatype) {
11537                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11538         }
11539         ndr->depth--;
11540         ndr->depth--;
11541 }
11542
11543 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11544 {
11545         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11546 }
11547
11548 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11549 {
11550         if (ndr_flags & NDR_SCALARS) {
11551                 NDR_CHECK(ndr_push_align(ndr, 5));
11552                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11553                 {
11554                         uint32_t _flags_save_string = ndr->flags;
11555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11556                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11557                         ndr->flags = _flags_save_string;
11558                 }
11559                 {
11560                         uint32_t _flags_save_string = ndr->flags;
11561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11563                         ndr->flags = _flags_save_string;
11564                 }
11565                 {
11566                         uint32_t _flags_save_string = ndr->flags;
11567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11568                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11569                         ndr->flags = _flags_save_string;
11570                 }
11571                 {
11572                         uint32_t _flags_save_string = ndr->flags;
11573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11574                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11575                         ndr->flags = _flags_save_string;
11576                 }
11577                 {
11578                         uint32_t _flags_save_string = ndr->flags;
11579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11580                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11581                         ndr->flags = _flags_save_string;
11582                 }
11583                 {
11584                         uint32_t _flags_save_string = ndr->flags;
11585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11586                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11587                         ndr->flags = _flags_save_string;
11588                 }
11589                 {
11590                         uint32_t _flags_save_string_array = ndr->flags;
11591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11592                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11593                         ndr->flags = _flags_save_string_array;
11594                 }
11595                 {
11596                         uint32_t _flags_save_string = ndr->flags;
11597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11598                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11599                         ndr->flags = _flags_save_string;
11600                 }
11601                 {
11602                         uint32_t _flags_save_string = ndr->flags;
11603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11604                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11605                         ndr->flags = _flags_save_string;
11606                 }
11607                 {
11608                         uint32_t _flags_save_string_array = ndr->flags;
11609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11610                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11611                         ndr->flags = _flags_save_string_array;
11612                 }
11613                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11614         }
11615         if (ndr_flags & NDR_BUFFERS) {
11616                 {
11617                         uint32_t _flags_save_string = ndr->flags;
11618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11619                         if (r->driver_name) {
11620                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11621                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11622                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11623                         }
11624                         ndr->flags = _flags_save_string;
11625                 }
11626                 {
11627                         uint32_t _flags_save_string = ndr->flags;
11628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11629                         if (r->architecture) {
11630                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11631                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11632                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11633                         }
11634                         ndr->flags = _flags_save_string;
11635                 }
11636                 {
11637                         uint32_t _flags_save_string = ndr->flags;
11638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11639                         if (r->driver_path) {
11640                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11641                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11642                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11643                         }
11644                         ndr->flags = _flags_save_string;
11645                 }
11646                 {
11647                         uint32_t _flags_save_string = ndr->flags;
11648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11649                         if (r->data_file) {
11650                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11652                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11653                         }
11654                         ndr->flags = _flags_save_string;
11655                 }
11656                 {
11657                         uint32_t _flags_save_string = ndr->flags;
11658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11659                         if (r->config_file) {
11660                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11661                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11662                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11663                         }
11664                         ndr->flags = _flags_save_string;
11665                 }
11666                 {
11667                         uint32_t _flags_save_string = ndr->flags;
11668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11669                         if (r->help_file) {
11670                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11671                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11672                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11673                         }
11674                         ndr->flags = _flags_save_string;
11675                 }
11676                 {
11677                         uint32_t _flags_save_string_array = ndr->flags;
11678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11679                         if (r->dependent_files) {
11680                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11681                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11682                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11683                         }
11684                         ndr->flags = _flags_save_string_array;
11685                 }
11686                 {
11687                         uint32_t _flags_save_string = ndr->flags;
11688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11689                         if (r->monitor_name) {
11690                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11692                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11693                         }
11694                         ndr->flags = _flags_save_string;
11695                 }
11696                 {
11697                         uint32_t _flags_save_string = ndr->flags;
11698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11699                         if (r->default_datatype) {
11700                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11702                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11703                         }
11704                         ndr->flags = _flags_save_string;
11705                 }
11706                 {
11707                         uint32_t _flags_save_string_array = ndr->flags;
11708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11709                         if (r->previous_names) {
11710                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
11711                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11712                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
11713                         }
11714                         ndr->flags = _flags_save_string_array;
11715                 }
11716         }
11717         return NDR_ERR_SUCCESS;
11718 }
11719
11720 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11721 {
11722         uint32_t _ptr_driver_name;
11723         TALLOC_CTX *_mem_save_driver_name_0;
11724         uint32_t _ptr_architecture;
11725         TALLOC_CTX *_mem_save_architecture_0;
11726         uint32_t _ptr_driver_path;
11727         TALLOC_CTX *_mem_save_driver_path_0;
11728         uint32_t _ptr_data_file;
11729         TALLOC_CTX *_mem_save_data_file_0;
11730         uint32_t _ptr_config_file;
11731         TALLOC_CTX *_mem_save_config_file_0;
11732         uint32_t _ptr_help_file;
11733         TALLOC_CTX *_mem_save_help_file_0;
11734         uint32_t _ptr_dependent_files;
11735         TALLOC_CTX *_mem_save_dependent_files_0;
11736         uint32_t _ptr_monitor_name;
11737         TALLOC_CTX *_mem_save_monitor_name_0;
11738         uint32_t _ptr_default_datatype;
11739         TALLOC_CTX *_mem_save_default_datatype_0;
11740         uint32_t _ptr_previous_names;
11741         TALLOC_CTX *_mem_save_previous_names_0;
11742         if (ndr_flags & NDR_SCALARS) {
11743                 NDR_CHECK(ndr_pull_align(ndr, 5));
11744                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11745                 {
11746                         uint32_t _flags_save_string = ndr->flags;
11747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11748                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11749                         if (_ptr_driver_name) {
11750                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11751                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11752                         } else {
11753                                 r->driver_name = NULL;
11754                         }
11755                         ndr->flags = _flags_save_string;
11756                 }
11757                 {
11758                         uint32_t _flags_save_string = ndr->flags;
11759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11760                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11761                         if (_ptr_architecture) {
11762                                 NDR_PULL_ALLOC(ndr, r->architecture);
11763                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11764                         } else {
11765                                 r->architecture = NULL;
11766                         }
11767                         ndr->flags = _flags_save_string;
11768                 }
11769                 {
11770                         uint32_t _flags_save_string = ndr->flags;
11771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11772                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11773                         if (_ptr_driver_path) {
11774                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11775                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11776                         } else {
11777                                 r->driver_path = NULL;
11778                         }
11779                         ndr->flags = _flags_save_string;
11780                 }
11781                 {
11782                         uint32_t _flags_save_string = ndr->flags;
11783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11784                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11785                         if (_ptr_data_file) {
11786                                 NDR_PULL_ALLOC(ndr, r->data_file);
11787                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11788                         } else {
11789                                 r->data_file = NULL;
11790                         }
11791                         ndr->flags = _flags_save_string;
11792                 }
11793                 {
11794                         uint32_t _flags_save_string = ndr->flags;
11795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11796                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11797                         if (_ptr_config_file) {
11798                                 NDR_PULL_ALLOC(ndr, r->config_file);
11799                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11800                         } else {
11801                                 r->config_file = NULL;
11802                         }
11803                         ndr->flags = _flags_save_string;
11804                 }
11805                 {
11806                         uint32_t _flags_save_string = ndr->flags;
11807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11808                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11809                         if (_ptr_help_file) {
11810                                 NDR_PULL_ALLOC(ndr, r->help_file);
11811                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11812                         } else {
11813                                 r->help_file = NULL;
11814                         }
11815                         ndr->flags = _flags_save_string;
11816                 }
11817                 {
11818                         uint32_t _flags_save_string_array = ndr->flags;
11819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11820                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11821                         if (_ptr_dependent_files) {
11822                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11823                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11824                         } else {
11825                                 r->dependent_files = NULL;
11826                         }
11827                         ndr->flags = _flags_save_string_array;
11828                 }
11829                 {
11830                         uint32_t _flags_save_string = ndr->flags;
11831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11832                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11833                         if (_ptr_monitor_name) {
11834                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11835                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11836                         } else {
11837                                 r->monitor_name = NULL;
11838                         }
11839                         ndr->flags = _flags_save_string;
11840                 }
11841                 {
11842                         uint32_t _flags_save_string = ndr->flags;
11843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11844                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11845                         if (_ptr_default_datatype) {
11846                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11847                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11848                         } else {
11849                                 r->default_datatype = NULL;
11850                         }
11851                         ndr->flags = _flags_save_string;
11852                 }
11853                 {
11854                         uint32_t _flags_save_string_array = ndr->flags;
11855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11856                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11857                         if (_ptr_previous_names) {
11858                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11859                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11860                         } else {
11861                                 r->previous_names = NULL;
11862                         }
11863                         ndr->flags = _flags_save_string_array;
11864                 }
11865                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11866         }
11867         if (ndr_flags & NDR_BUFFERS) {
11868                 {
11869                         uint32_t _flags_save_string = ndr->flags;
11870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11871                         if (r->driver_name) {
11872                                 uint32_t _relative_save_offset;
11873                                 _relative_save_offset = ndr->offset;
11874                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11875                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11876                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11877                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11878                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11879                                 if (ndr->offset > ndr->relative_highest_offset) {
11880                                         ndr->relative_highest_offset = ndr->offset;
11881                                 }
11882                                 ndr->offset = _relative_save_offset;
11883                         }
11884                         ndr->flags = _flags_save_string;
11885                 }
11886                 {
11887                         uint32_t _flags_save_string = ndr->flags;
11888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11889                         if (r->architecture) {
11890                                 uint32_t _relative_save_offset;
11891                                 _relative_save_offset = ndr->offset;
11892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11893                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11894                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11897                                 if (ndr->offset > ndr->relative_highest_offset) {
11898                                         ndr->relative_highest_offset = ndr->offset;
11899                                 }
11900                                 ndr->offset = _relative_save_offset;
11901                         }
11902                         ndr->flags = _flags_save_string;
11903                 }
11904                 {
11905                         uint32_t _flags_save_string = ndr->flags;
11906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11907                         if (r->driver_path) {
11908                                 uint32_t _relative_save_offset;
11909                                 _relative_save_offset = ndr->offset;
11910                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11911                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11912                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11913                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11914                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11915                                 if (ndr->offset > ndr->relative_highest_offset) {
11916                                         ndr->relative_highest_offset = ndr->offset;
11917                                 }
11918                                 ndr->offset = _relative_save_offset;
11919                         }
11920                         ndr->flags = _flags_save_string;
11921                 }
11922                 {
11923                         uint32_t _flags_save_string = ndr->flags;
11924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11925                         if (r->data_file) {
11926                                 uint32_t _relative_save_offset;
11927                                 _relative_save_offset = ndr->offset;
11928                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11929                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11930                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11931                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11932                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11933                                 if (ndr->offset > ndr->relative_highest_offset) {
11934                                         ndr->relative_highest_offset = ndr->offset;
11935                                 }
11936                                 ndr->offset = _relative_save_offset;
11937                         }
11938                         ndr->flags = _flags_save_string;
11939                 }
11940                 {
11941                         uint32_t _flags_save_string = ndr->flags;
11942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11943                         if (r->config_file) {
11944                                 uint32_t _relative_save_offset;
11945                                 _relative_save_offset = ndr->offset;
11946                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11947                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11948                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11949                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11950                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11951                                 if (ndr->offset > ndr->relative_highest_offset) {
11952                                         ndr->relative_highest_offset = ndr->offset;
11953                                 }
11954                                 ndr->offset = _relative_save_offset;
11955                         }
11956                         ndr->flags = _flags_save_string;
11957                 }
11958                 {
11959                         uint32_t _flags_save_string = ndr->flags;
11960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11961                         if (r->help_file) {
11962                                 uint32_t _relative_save_offset;
11963                                 _relative_save_offset = ndr->offset;
11964                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11965                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11966                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11967                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11968                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11969                                 if (ndr->offset > ndr->relative_highest_offset) {
11970                                         ndr->relative_highest_offset = ndr->offset;
11971                                 }
11972                                 ndr->offset = _relative_save_offset;
11973                         }
11974                         ndr->flags = _flags_save_string;
11975                 }
11976                 {
11977                         uint32_t _flags_save_string_array = ndr->flags;
11978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11979                         if (r->dependent_files) {
11980                                 uint32_t _relative_save_offset;
11981                                 _relative_save_offset = ndr->offset;
11982                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11983                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11984                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11985                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11986                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11987                                 if (ndr->offset > ndr->relative_highest_offset) {
11988                                         ndr->relative_highest_offset = ndr->offset;
11989                                 }
11990                                 ndr->offset = _relative_save_offset;
11991                         }
11992                         ndr->flags = _flags_save_string_array;
11993                 }
11994                 {
11995                         uint32_t _flags_save_string = ndr->flags;
11996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11997                         if (r->monitor_name) {
11998                                 uint32_t _relative_save_offset;
11999                                 _relative_save_offset = ndr->offset;
12000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12001                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12002                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12005                                 if (ndr->offset > ndr->relative_highest_offset) {
12006                                         ndr->relative_highest_offset = ndr->offset;
12007                                 }
12008                                 ndr->offset = _relative_save_offset;
12009                         }
12010                         ndr->flags = _flags_save_string;
12011                 }
12012                 {
12013                         uint32_t _flags_save_string = ndr->flags;
12014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12015                         if (r->default_datatype) {
12016                                 uint32_t _relative_save_offset;
12017                                 _relative_save_offset = ndr->offset;
12018                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12019                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12020                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12021                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12022                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12023                                 if (ndr->offset > ndr->relative_highest_offset) {
12024                                         ndr->relative_highest_offset = ndr->offset;
12025                                 }
12026                                 ndr->offset = _relative_save_offset;
12027                         }
12028                         ndr->flags = _flags_save_string;
12029                 }
12030                 {
12031                         uint32_t _flags_save_string_array = ndr->flags;
12032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12033                         if (r->previous_names) {
12034                                 uint32_t _relative_save_offset;
12035                                 _relative_save_offset = ndr->offset;
12036                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12037                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12038                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12039                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12040                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12041                                 if (ndr->offset > ndr->relative_highest_offset) {
12042                                         ndr->relative_highest_offset = ndr->offset;
12043                                 }
12044                                 ndr->offset = _relative_save_offset;
12045                         }
12046                         ndr->flags = _flags_save_string_array;
12047                 }
12048         }
12049         return NDR_ERR_SUCCESS;
12050 }
12051
12052 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
12053 {
12054         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
12055         ndr->depth++;
12056         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12057         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12058         ndr->depth++;
12059         if (r->driver_name) {
12060                 ndr_print_string(ndr, "driver_name", r->driver_name);
12061         }
12062         ndr->depth--;
12063         ndr_print_ptr(ndr, "architecture", r->architecture);
12064         ndr->depth++;
12065         if (r->architecture) {
12066                 ndr_print_string(ndr, "architecture", r->architecture);
12067         }
12068         ndr->depth--;
12069         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12070         ndr->depth++;
12071         if (r->driver_path) {
12072                 ndr_print_string(ndr, "driver_path", r->driver_path);
12073         }
12074         ndr->depth--;
12075         ndr_print_ptr(ndr, "data_file", r->data_file);
12076         ndr->depth++;
12077         if (r->data_file) {
12078                 ndr_print_string(ndr, "data_file", r->data_file);
12079         }
12080         ndr->depth--;
12081         ndr_print_ptr(ndr, "config_file", r->config_file);
12082         ndr->depth++;
12083         if (r->config_file) {
12084                 ndr_print_string(ndr, "config_file", r->config_file);
12085         }
12086         ndr->depth--;
12087         ndr_print_ptr(ndr, "help_file", r->help_file);
12088         ndr->depth++;
12089         if (r->help_file) {
12090                 ndr_print_string(ndr, "help_file", r->help_file);
12091         }
12092         ndr->depth--;
12093         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12094         ndr->depth++;
12095         if (r->dependent_files) {
12096                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12097         }
12098         ndr->depth--;
12099         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12100         ndr->depth++;
12101         if (r->monitor_name) {
12102                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12103         }
12104         ndr->depth--;
12105         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12106         ndr->depth++;
12107         if (r->default_datatype) {
12108                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12109         }
12110         ndr->depth--;
12111         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12112         ndr->depth++;
12113         if (r->previous_names) {
12114                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12115         }
12116         ndr->depth--;
12117         ndr->depth--;
12118 }
12119
12120 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12121 {
12122         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12123 }
12124
12125 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12126 {
12127         if (ndr_flags & NDR_SCALARS) {
12128                 NDR_CHECK(ndr_push_align(ndr, 5));
12129                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12130                 {
12131                         uint32_t _flags_save_string = ndr->flags;
12132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12133                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12134                         ndr->flags = _flags_save_string;
12135                 }
12136                 {
12137                         uint32_t _flags_save_string = ndr->flags;
12138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12139                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12140                         ndr->flags = _flags_save_string;
12141                 }
12142                 {
12143                         uint32_t _flags_save_string = ndr->flags;
12144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12145                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12146                         ndr->flags = _flags_save_string;
12147                 }
12148                 {
12149                         uint32_t _flags_save_string = ndr->flags;
12150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12151                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12152                         ndr->flags = _flags_save_string;
12153                 }
12154                 {
12155                         uint32_t _flags_save_string = ndr->flags;
12156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12157                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12158                         ndr->flags = _flags_save_string;
12159                 }
12160                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12163                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12164         }
12165         if (ndr_flags & NDR_BUFFERS) {
12166                 {
12167                         uint32_t _flags_save_string = ndr->flags;
12168                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12169                         if (r->driver_name) {
12170                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12171                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12172                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12173                         }
12174                         ndr->flags = _flags_save_string;
12175                 }
12176                 {
12177                         uint32_t _flags_save_string = ndr->flags;
12178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12179                         if (r->architecture) {
12180                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12181                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12182                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12183                         }
12184                         ndr->flags = _flags_save_string;
12185                 }
12186                 {
12187                         uint32_t _flags_save_string = ndr->flags;
12188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12189                         if (r->driver_path) {
12190                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12191                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12192                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12193                         }
12194                         ndr->flags = _flags_save_string;
12195                 }
12196                 {
12197                         uint32_t _flags_save_string = ndr->flags;
12198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12199                         if (r->data_file) {
12200                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12201                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12202                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12203                         }
12204                         ndr->flags = _flags_save_string;
12205                 }
12206                 {
12207                         uint32_t _flags_save_string = ndr->flags;
12208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12209                         if (r->config_file) {
12210                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12211                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12212                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12213                         }
12214                         ndr->flags = _flags_save_string;
12215                 }
12216         }
12217         return NDR_ERR_SUCCESS;
12218 }
12219
12220 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12221 {
12222         uint32_t _ptr_driver_name;
12223         TALLOC_CTX *_mem_save_driver_name_0;
12224         uint32_t _ptr_architecture;
12225         TALLOC_CTX *_mem_save_architecture_0;
12226         uint32_t _ptr_driver_path;
12227         TALLOC_CTX *_mem_save_driver_path_0;
12228         uint32_t _ptr_data_file;
12229         TALLOC_CTX *_mem_save_data_file_0;
12230         uint32_t _ptr_config_file;
12231         TALLOC_CTX *_mem_save_config_file_0;
12232         if (ndr_flags & NDR_SCALARS) {
12233                 NDR_CHECK(ndr_pull_align(ndr, 5));
12234                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12235                 {
12236                         uint32_t _flags_save_string = ndr->flags;
12237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12239                         if (_ptr_driver_name) {
12240                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12242                         } else {
12243                                 r->driver_name = NULL;
12244                         }
12245                         ndr->flags = _flags_save_string;
12246                 }
12247                 {
12248                         uint32_t _flags_save_string = ndr->flags;
12249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12250                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12251                         if (_ptr_architecture) {
12252                                 NDR_PULL_ALLOC(ndr, r->architecture);
12253                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12254                         } else {
12255                                 r->architecture = NULL;
12256                         }
12257                         ndr->flags = _flags_save_string;
12258                 }
12259                 {
12260                         uint32_t _flags_save_string = ndr->flags;
12261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12262                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12263                         if (_ptr_driver_path) {
12264                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12265                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12266                         } else {
12267                                 r->driver_path = NULL;
12268                         }
12269                         ndr->flags = _flags_save_string;
12270                 }
12271                 {
12272                         uint32_t _flags_save_string = ndr->flags;
12273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12274                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12275                         if (_ptr_data_file) {
12276                                 NDR_PULL_ALLOC(ndr, r->data_file);
12277                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12278                         } else {
12279                                 r->data_file = NULL;
12280                         }
12281                         ndr->flags = _flags_save_string;
12282                 }
12283                 {
12284                         uint32_t _flags_save_string = ndr->flags;
12285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12287                         if (_ptr_config_file) {
12288                                 NDR_PULL_ALLOC(ndr, r->config_file);
12289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12290                         } else {
12291                                 r->config_file = NULL;
12292                         }
12293                         ndr->flags = _flags_save_string;
12294                 }
12295                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12298                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12299         }
12300         if (ndr_flags & NDR_BUFFERS) {
12301                 {
12302                         uint32_t _flags_save_string = ndr->flags;
12303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12304                         if (r->driver_name) {
12305                                 uint32_t _relative_save_offset;
12306                                 _relative_save_offset = ndr->offset;
12307                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12308                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12309                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12310                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12311                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12312                                 if (ndr->offset > ndr->relative_highest_offset) {
12313                                         ndr->relative_highest_offset = ndr->offset;
12314                                 }
12315                                 ndr->offset = _relative_save_offset;
12316                         }
12317                         ndr->flags = _flags_save_string;
12318                 }
12319                 {
12320                         uint32_t _flags_save_string = ndr->flags;
12321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12322                         if (r->architecture) {
12323                                 uint32_t _relative_save_offset;
12324                                 _relative_save_offset = ndr->offset;
12325                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12326                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12327                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12328                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12329                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12330                                 if (ndr->offset > ndr->relative_highest_offset) {
12331                                         ndr->relative_highest_offset = ndr->offset;
12332                                 }
12333                                 ndr->offset = _relative_save_offset;
12334                         }
12335                         ndr->flags = _flags_save_string;
12336                 }
12337                 {
12338                         uint32_t _flags_save_string = ndr->flags;
12339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12340                         if (r->driver_path) {
12341                                 uint32_t _relative_save_offset;
12342                                 _relative_save_offset = ndr->offset;
12343                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12344                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12345                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12346                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12347                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12348                                 if (ndr->offset > ndr->relative_highest_offset) {
12349                                         ndr->relative_highest_offset = ndr->offset;
12350                                 }
12351                                 ndr->offset = _relative_save_offset;
12352                         }
12353                         ndr->flags = _flags_save_string;
12354                 }
12355                 {
12356                         uint32_t _flags_save_string = ndr->flags;
12357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12358                         if (r->data_file) {
12359                                 uint32_t _relative_save_offset;
12360                                 _relative_save_offset = ndr->offset;
12361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12362                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12363                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12366                                 if (ndr->offset > ndr->relative_highest_offset) {
12367                                         ndr->relative_highest_offset = ndr->offset;
12368                                 }
12369                                 ndr->offset = _relative_save_offset;
12370                         }
12371                         ndr->flags = _flags_save_string;
12372                 }
12373                 {
12374                         uint32_t _flags_save_string = ndr->flags;
12375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12376                         if (r->config_file) {
12377                                 uint32_t _relative_save_offset;
12378                                 _relative_save_offset = ndr->offset;
12379                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12380                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12381                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12382                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12383                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12384                                 if (ndr->offset > ndr->relative_highest_offset) {
12385                                         ndr->relative_highest_offset = ndr->offset;
12386                                 }
12387                                 ndr->offset = _relative_save_offset;
12388                         }
12389                         ndr->flags = _flags_save_string;
12390                 }
12391         }
12392         return NDR_ERR_SUCCESS;
12393 }
12394
12395 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12396 {
12397         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12398         ndr->depth++;
12399         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12400         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12401         ndr->depth++;
12402         if (r->driver_name) {
12403                 ndr_print_string(ndr, "driver_name", r->driver_name);
12404         }
12405         ndr->depth--;
12406         ndr_print_ptr(ndr, "architecture", r->architecture);
12407         ndr->depth++;
12408         if (r->architecture) {
12409                 ndr_print_string(ndr, "architecture", r->architecture);
12410         }
12411         ndr->depth--;
12412         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12413         ndr->depth++;
12414         if (r->driver_path) {
12415                 ndr_print_string(ndr, "driver_path", r->driver_path);
12416         }
12417         ndr->depth--;
12418         ndr_print_ptr(ndr, "data_file", r->data_file);
12419         ndr->depth++;
12420         if (r->data_file) {
12421                 ndr_print_string(ndr, "data_file", r->data_file);
12422         }
12423         ndr->depth--;
12424         ndr_print_ptr(ndr, "config_file", r->config_file);
12425         ndr->depth++;
12426         if (r->config_file) {
12427                 ndr_print_string(ndr, "config_file", r->config_file);
12428         }
12429         ndr->depth--;
12430         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12431         ndr_print_uint32(ndr, "config_version", r->config_version);
12432         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12433         ndr->depth--;
12434 }
12435
12436 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12437 {
12438         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12439 }
12440
12441 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12442 {
12443         if (ndr_flags & NDR_SCALARS) {
12444                 NDR_CHECK(ndr_push_align(ndr, 8));
12445                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12446                 {
12447                         uint32_t _flags_save_string = ndr->flags;
12448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12449                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12450                         ndr->flags = _flags_save_string;
12451                 }
12452                 {
12453                         uint32_t _flags_save_string = ndr->flags;
12454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12455                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12456                         ndr->flags = _flags_save_string;
12457                 }
12458                 {
12459                         uint32_t _flags_save_string = ndr->flags;
12460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12461                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12462                         ndr->flags = _flags_save_string;
12463                 }
12464                 {
12465                         uint32_t _flags_save_string = ndr->flags;
12466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12467                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12468                         ndr->flags = _flags_save_string;
12469                 }
12470                 {
12471                         uint32_t _flags_save_string = ndr->flags;
12472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12473                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12474                         ndr->flags = _flags_save_string;
12475                 }
12476                 {
12477                         uint32_t _flags_save_string = ndr->flags;
12478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12479                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12480                         ndr->flags = _flags_save_string;
12481                 }
12482                 {
12483                         uint32_t _flags_save_string_array = ndr->flags;
12484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12485                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12486                         ndr->flags = _flags_save_string_array;
12487                 }
12488                 {
12489                         uint32_t _flags_save_string = ndr->flags;
12490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12491                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12492                         ndr->flags = _flags_save_string;
12493                 }
12494                 {
12495                         uint32_t _flags_save_string = ndr->flags;
12496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12497                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12498                         ndr->flags = _flags_save_string;
12499                 }
12500                 {
12501                         uint32_t _flags_save_string_array = ndr->flags;
12502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12503                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12504                         ndr->flags = _flags_save_string_array;
12505                 }
12506                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12507                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12508                 {
12509                         uint32_t _flags_save_string = ndr->flags;
12510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12512                         ndr->flags = _flags_save_string;
12513                 }
12514                 {
12515                         uint32_t _flags_save_string = ndr->flags;
12516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12518                         ndr->flags = _flags_save_string;
12519                 }
12520                 {
12521                         uint32_t _flags_save_string = ndr->flags;
12522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12524                         ndr->flags = _flags_save_string;
12525                 }
12526                 {
12527                         uint32_t _flags_save_string = ndr->flags;
12528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12530                         ndr->flags = _flags_save_string;
12531                 }
12532                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12533         }
12534         if (ndr_flags & NDR_BUFFERS) {
12535                 {
12536                         uint32_t _flags_save_string = ndr->flags;
12537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12538                         if (r->driver_name) {
12539                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12540                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12541                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12542                         }
12543                         ndr->flags = _flags_save_string;
12544                 }
12545                 {
12546                         uint32_t _flags_save_string = ndr->flags;
12547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12548                         if (r->architecture) {
12549                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12550                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12551                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12552                         }
12553                         ndr->flags = _flags_save_string;
12554                 }
12555                 {
12556                         uint32_t _flags_save_string = ndr->flags;
12557                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12558                         if (r->driver_path) {
12559                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12560                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12561                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12562                         }
12563                         ndr->flags = _flags_save_string;
12564                 }
12565                 {
12566                         uint32_t _flags_save_string = ndr->flags;
12567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12568                         if (r->data_file) {
12569                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12570                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12571                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12572                         }
12573                         ndr->flags = _flags_save_string;
12574                 }
12575                 {
12576                         uint32_t _flags_save_string = ndr->flags;
12577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12578                         if (r->config_file) {
12579                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12580                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12581                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12582                         }
12583                         ndr->flags = _flags_save_string;
12584                 }
12585                 {
12586                         uint32_t _flags_save_string = ndr->flags;
12587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12588                         if (r->help_file) {
12589                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12591                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12592                         }
12593                         ndr->flags = _flags_save_string;
12594                 }
12595                 {
12596                         uint32_t _flags_save_string_array = ndr->flags;
12597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12598                         if (r->dependent_files) {
12599                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12600                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12601                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12602                         }
12603                         ndr->flags = _flags_save_string_array;
12604                 }
12605                 {
12606                         uint32_t _flags_save_string = ndr->flags;
12607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12608                         if (r->monitor_name) {
12609                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12610                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12611                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12612                         }
12613                         ndr->flags = _flags_save_string;
12614                 }
12615                 {
12616                         uint32_t _flags_save_string = ndr->flags;
12617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12618                         if (r->default_datatype) {
12619                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12621                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12622                         }
12623                         ndr->flags = _flags_save_string;
12624                 }
12625                 {
12626                         uint32_t _flags_save_string_array = ndr->flags;
12627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12628                         if (r->previous_names) {
12629                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12630                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12631                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12632                         }
12633                         ndr->flags = _flags_save_string_array;
12634                 }
12635                 {
12636                         uint32_t _flags_save_string = ndr->flags;
12637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12638                         if (r->manufacturer_name) {
12639                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12640                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12641                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12642                         }
12643                         ndr->flags = _flags_save_string;
12644                 }
12645                 {
12646                         uint32_t _flags_save_string = ndr->flags;
12647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12648                         if (r->manufacturer_url) {
12649                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12650                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12651                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12652                         }
12653                         ndr->flags = _flags_save_string;
12654                 }
12655                 {
12656                         uint32_t _flags_save_string = ndr->flags;
12657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12658                         if (r->hardware_id) {
12659                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12661                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
12662                         }
12663                         ndr->flags = _flags_save_string;
12664                 }
12665                 {
12666                         uint32_t _flags_save_string = ndr->flags;
12667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12668                         if (r->provider) {
12669                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12670                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12671                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12672                         }
12673                         ndr->flags = _flags_save_string;
12674                 }
12675         }
12676         return NDR_ERR_SUCCESS;
12677 }
12678
12679 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12680 {
12681         uint32_t _ptr_driver_name;
12682         TALLOC_CTX *_mem_save_driver_name_0;
12683         uint32_t _ptr_architecture;
12684         TALLOC_CTX *_mem_save_architecture_0;
12685         uint32_t _ptr_driver_path;
12686         TALLOC_CTX *_mem_save_driver_path_0;
12687         uint32_t _ptr_data_file;
12688         TALLOC_CTX *_mem_save_data_file_0;
12689         uint32_t _ptr_config_file;
12690         TALLOC_CTX *_mem_save_config_file_0;
12691         uint32_t _ptr_help_file;
12692         TALLOC_CTX *_mem_save_help_file_0;
12693         uint32_t _ptr_dependent_files;
12694         TALLOC_CTX *_mem_save_dependent_files_0;
12695         uint32_t _ptr_monitor_name;
12696         TALLOC_CTX *_mem_save_monitor_name_0;
12697         uint32_t _ptr_default_datatype;
12698         TALLOC_CTX *_mem_save_default_datatype_0;
12699         uint32_t _ptr_previous_names;
12700         TALLOC_CTX *_mem_save_previous_names_0;
12701         uint32_t _ptr_manufacturer_name;
12702         TALLOC_CTX *_mem_save_manufacturer_name_0;
12703         uint32_t _ptr_manufacturer_url;
12704         TALLOC_CTX *_mem_save_manufacturer_url_0;
12705         uint32_t _ptr_hardware_id;
12706         TALLOC_CTX *_mem_save_hardware_id_0;
12707         uint32_t _ptr_provider;
12708         TALLOC_CTX *_mem_save_provider_0;
12709         if (ndr_flags & NDR_SCALARS) {
12710                 NDR_CHECK(ndr_pull_align(ndr, 8));
12711                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
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_driver_name));
12716                         if (_ptr_driver_name) {
12717                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12719                         } else {
12720                                 r->driver_name = NULL;
12721                         }
12722                         ndr->flags = _flags_save_string;
12723                 }
12724                 {
12725                         uint32_t _flags_save_string = ndr->flags;
12726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12728                         if (_ptr_architecture) {
12729                                 NDR_PULL_ALLOC(ndr, r->architecture);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12731                         } else {
12732                                 r->architecture = NULL;
12733                         }
12734                         ndr->flags = _flags_save_string;
12735                 }
12736                 {
12737                         uint32_t _flags_save_string = ndr->flags;
12738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12739                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12740                         if (_ptr_driver_path) {
12741                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12743                         } else {
12744                                 r->driver_path = NULL;
12745                         }
12746                         ndr->flags = _flags_save_string;
12747                 }
12748                 {
12749                         uint32_t _flags_save_string = ndr->flags;
12750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12752                         if (_ptr_data_file) {
12753                                 NDR_PULL_ALLOC(ndr, r->data_file);
12754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12755                         } else {
12756                                 r->data_file = NULL;
12757                         }
12758                         ndr->flags = _flags_save_string;
12759                 }
12760                 {
12761                         uint32_t _flags_save_string = ndr->flags;
12762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12764                         if (_ptr_config_file) {
12765                                 NDR_PULL_ALLOC(ndr, r->config_file);
12766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12767                         } else {
12768                                 r->config_file = NULL;
12769                         }
12770                         ndr->flags = _flags_save_string;
12771                 }
12772                 {
12773                         uint32_t _flags_save_string = ndr->flags;
12774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12776                         if (_ptr_help_file) {
12777                                 NDR_PULL_ALLOC(ndr, r->help_file);
12778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12779                         } else {
12780                                 r->help_file = NULL;
12781                         }
12782                         ndr->flags = _flags_save_string;
12783                 }
12784                 {
12785                         uint32_t _flags_save_string_array = ndr->flags;
12786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12788                         if (_ptr_dependent_files) {
12789                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12791                         } else {
12792                                 r->dependent_files = NULL;
12793                         }
12794                         ndr->flags = _flags_save_string_array;
12795                 }
12796                 {
12797                         uint32_t _flags_save_string = ndr->flags;
12798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12800                         if (_ptr_monitor_name) {
12801                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12803                         } else {
12804                                 r->monitor_name = NULL;
12805                         }
12806                         ndr->flags = _flags_save_string;
12807                 }
12808                 {
12809                         uint32_t _flags_save_string = ndr->flags;
12810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12812                         if (_ptr_default_datatype) {
12813                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12815                         } else {
12816                                 r->default_datatype = NULL;
12817                         }
12818                         ndr->flags = _flags_save_string;
12819                 }
12820                 {
12821                         uint32_t _flags_save_string_array = ndr->flags;
12822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12823                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12824                         if (_ptr_previous_names) {
12825                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12826                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12827                         } else {
12828                                 r->previous_names = NULL;
12829                         }
12830                         ndr->flags = _flags_save_string_array;
12831                 }
12832                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12833                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12834                 {
12835                         uint32_t _flags_save_string = ndr->flags;
12836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12837                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12838                         if (_ptr_manufacturer_name) {
12839                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12840                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12841                         } else {
12842                                 r->manufacturer_name = NULL;
12843                         }
12844                         ndr->flags = _flags_save_string;
12845                 }
12846                 {
12847                         uint32_t _flags_save_string = ndr->flags;
12848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12849                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12850                         if (_ptr_manufacturer_url) {
12851                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12852                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12853                         } else {
12854                                 r->manufacturer_url = NULL;
12855                         }
12856                         ndr->flags = _flags_save_string;
12857                 }
12858                 {
12859                         uint32_t _flags_save_string = ndr->flags;
12860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12861                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12862                         if (_ptr_hardware_id) {
12863                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12864                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12865                         } else {
12866                                 r->hardware_id = NULL;
12867                         }
12868                         ndr->flags = _flags_save_string;
12869                 }
12870                 {
12871                         uint32_t _flags_save_string = ndr->flags;
12872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12873                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12874                         if (_ptr_provider) {
12875                                 NDR_PULL_ALLOC(ndr, r->provider);
12876                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12877                         } else {
12878                                 r->provider = NULL;
12879                         }
12880                         ndr->flags = _flags_save_string;
12881                 }
12882                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12883         }
12884         if (ndr_flags & NDR_BUFFERS) {
12885                 {
12886                         uint32_t _flags_save_string = ndr->flags;
12887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12888                         if (r->driver_name) {
12889                                 uint32_t _relative_save_offset;
12890                                 _relative_save_offset = ndr->offset;
12891                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12892                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12893                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12894                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12895                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12896                                 if (ndr->offset > ndr->relative_highest_offset) {
12897                                         ndr->relative_highest_offset = ndr->offset;
12898                                 }
12899                                 ndr->offset = _relative_save_offset;
12900                         }
12901                         ndr->flags = _flags_save_string;
12902                 }
12903                 {
12904                         uint32_t _flags_save_string = ndr->flags;
12905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12906                         if (r->architecture) {
12907                                 uint32_t _relative_save_offset;
12908                                 _relative_save_offset = ndr->offset;
12909                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12910                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12911                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12912                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12913                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12914                                 if (ndr->offset > ndr->relative_highest_offset) {
12915                                         ndr->relative_highest_offset = ndr->offset;
12916                                 }
12917                                 ndr->offset = _relative_save_offset;
12918                         }
12919                         ndr->flags = _flags_save_string;
12920                 }
12921                 {
12922                         uint32_t _flags_save_string = ndr->flags;
12923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12924                         if (r->driver_path) {
12925                                 uint32_t _relative_save_offset;
12926                                 _relative_save_offset = ndr->offset;
12927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12928                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12929                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12932                                 if (ndr->offset > ndr->relative_highest_offset) {
12933                                         ndr->relative_highest_offset = ndr->offset;
12934                                 }
12935                                 ndr->offset = _relative_save_offset;
12936                         }
12937                         ndr->flags = _flags_save_string;
12938                 }
12939                 {
12940                         uint32_t _flags_save_string = ndr->flags;
12941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12942                         if (r->data_file) {
12943                                 uint32_t _relative_save_offset;
12944                                 _relative_save_offset = ndr->offset;
12945                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12946                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12947                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12948                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12949                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12950                                 if (ndr->offset > ndr->relative_highest_offset) {
12951                                         ndr->relative_highest_offset = ndr->offset;
12952                                 }
12953                                 ndr->offset = _relative_save_offset;
12954                         }
12955                         ndr->flags = _flags_save_string;
12956                 }
12957                 {
12958                         uint32_t _flags_save_string = ndr->flags;
12959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12960                         if (r->config_file) {
12961                                 uint32_t _relative_save_offset;
12962                                 _relative_save_offset = ndr->offset;
12963                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12964                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12965                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12966                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12967                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12968                                 if (ndr->offset > ndr->relative_highest_offset) {
12969                                         ndr->relative_highest_offset = ndr->offset;
12970                                 }
12971                                 ndr->offset = _relative_save_offset;
12972                         }
12973                         ndr->flags = _flags_save_string;
12974                 }
12975                 {
12976                         uint32_t _flags_save_string = ndr->flags;
12977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12978                         if (r->help_file) {
12979                                 uint32_t _relative_save_offset;
12980                                 _relative_save_offset = ndr->offset;
12981                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12982                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12983                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12984                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12985                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12986                                 if (ndr->offset > ndr->relative_highest_offset) {
12987                                         ndr->relative_highest_offset = ndr->offset;
12988                                 }
12989                                 ndr->offset = _relative_save_offset;
12990                         }
12991                         ndr->flags = _flags_save_string;
12992                 }
12993                 {
12994                         uint32_t _flags_save_string_array = ndr->flags;
12995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12996                         if (r->dependent_files) {
12997                                 uint32_t _relative_save_offset;
12998                                 _relative_save_offset = ndr->offset;
12999                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13000                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13001                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13002                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13003                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13004                                 if (ndr->offset > ndr->relative_highest_offset) {
13005                                         ndr->relative_highest_offset = ndr->offset;
13006                                 }
13007                                 ndr->offset = _relative_save_offset;
13008                         }
13009                         ndr->flags = _flags_save_string_array;
13010                 }
13011                 {
13012                         uint32_t _flags_save_string = ndr->flags;
13013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13014                         if (r->monitor_name) {
13015                                 uint32_t _relative_save_offset;
13016                                 _relative_save_offset = ndr->offset;
13017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13018                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13019                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13020                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13022                                 if (ndr->offset > ndr->relative_highest_offset) {
13023                                         ndr->relative_highest_offset = ndr->offset;
13024                                 }
13025                                 ndr->offset = _relative_save_offset;
13026                         }
13027                         ndr->flags = _flags_save_string;
13028                 }
13029                 {
13030                         uint32_t _flags_save_string = ndr->flags;
13031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13032                         if (r->default_datatype) {
13033                                 uint32_t _relative_save_offset;
13034                                 _relative_save_offset = ndr->offset;
13035                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13036                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13037                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13038                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13039                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13040                                 if (ndr->offset > ndr->relative_highest_offset) {
13041                                         ndr->relative_highest_offset = ndr->offset;
13042                                 }
13043                                 ndr->offset = _relative_save_offset;
13044                         }
13045                         ndr->flags = _flags_save_string;
13046                 }
13047                 {
13048                         uint32_t _flags_save_string_array = ndr->flags;
13049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13050                         if (r->previous_names) {
13051                                 uint32_t _relative_save_offset;
13052                                 _relative_save_offset = ndr->offset;
13053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13054                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13055                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13056                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13058                                 if (ndr->offset > ndr->relative_highest_offset) {
13059                                         ndr->relative_highest_offset = ndr->offset;
13060                                 }
13061                                 ndr->offset = _relative_save_offset;
13062                         }
13063                         ndr->flags = _flags_save_string_array;
13064                 }
13065                 {
13066                         uint32_t _flags_save_string = ndr->flags;
13067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13068                         if (r->manufacturer_name) {
13069                                 uint32_t _relative_save_offset;
13070                                 _relative_save_offset = ndr->offset;
13071                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13072                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13073                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13074                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13075                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13076                                 if (ndr->offset > ndr->relative_highest_offset) {
13077                                         ndr->relative_highest_offset = ndr->offset;
13078                                 }
13079                                 ndr->offset = _relative_save_offset;
13080                         }
13081                         ndr->flags = _flags_save_string;
13082                 }
13083                 {
13084                         uint32_t _flags_save_string = ndr->flags;
13085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13086                         if (r->manufacturer_url) {
13087                                 uint32_t _relative_save_offset;
13088                                 _relative_save_offset = ndr->offset;
13089                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13090                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13091                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13092                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13093                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13094                                 if (ndr->offset > ndr->relative_highest_offset) {
13095                                         ndr->relative_highest_offset = ndr->offset;
13096                                 }
13097                                 ndr->offset = _relative_save_offset;
13098                         }
13099                         ndr->flags = _flags_save_string;
13100                 }
13101                 {
13102                         uint32_t _flags_save_string = ndr->flags;
13103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13104                         if (r->hardware_id) {
13105                                 uint32_t _relative_save_offset;
13106                                 _relative_save_offset = ndr->offset;
13107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13108                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13109                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13112                                 if (ndr->offset > ndr->relative_highest_offset) {
13113                                         ndr->relative_highest_offset = ndr->offset;
13114                                 }
13115                                 ndr->offset = _relative_save_offset;
13116                         }
13117                         ndr->flags = _flags_save_string;
13118                 }
13119                 {
13120                         uint32_t _flags_save_string = ndr->flags;
13121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13122                         if (r->provider) {
13123                                 uint32_t _relative_save_offset;
13124                                 _relative_save_offset = ndr->offset;
13125                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13126                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13127                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13128                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13129                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13130                                 if (ndr->offset > ndr->relative_highest_offset) {
13131                                         ndr->relative_highest_offset = ndr->offset;
13132                                 }
13133                                 ndr->offset = _relative_save_offset;
13134                         }
13135                         ndr->flags = _flags_save_string;
13136                 }
13137         }
13138         return NDR_ERR_SUCCESS;
13139 }
13140
13141 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13142 {
13143         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13144         ndr->depth++;
13145         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13146         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13147         ndr->depth++;
13148         if (r->driver_name) {
13149                 ndr_print_string(ndr, "driver_name", r->driver_name);
13150         }
13151         ndr->depth--;
13152         ndr_print_ptr(ndr, "architecture", r->architecture);
13153         ndr->depth++;
13154         if (r->architecture) {
13155                 ndr_print_string(ndr, "architecture", r->architecture);
13156         }
13157         ndr->depth--;
13158         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13159         ndr->depth++;
13160         if (r->driver_path) {
13161                 ndr_print_string(ndr, "driver_path", r->driver_path);
13162         }
13163         ndr->depth--;
13164         ndr_print_ptr(ndr, "data_file", r->data_file);
13165         ndr->depth++;
13166         if (r->data_file) {
13167                 ndr_print_string(ndr, "data_file", r->data_file);
13168         }
13169         ndr->depth--;
13170         ndr_print_ptr(ndr, "config_file", r->config_file);
13171         ndr->depth++;
13172         if (r->config_file) {
13173                 ndr_print_string(ndr, "config_file", r->config_file);
13174         }
13175         ndr->depth--;
13176         ndr_print_ptr(ndr, "help_file", r->help_file);
13177         ndr->depth++;
13178         if (r->help_file) {
13179                 ndr_print_string(ndr, "help_file", r->help_file);
13180         }
13181         ndr->depth--;
13182         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13183         ndr->depth++;
13184         if (r->dependent_files) {
13185                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13186         }
13187         ndr->depth--;
13188         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13189         ndr->depth++;
13190         if (r->monitor_name) {
13191                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13192         }
13193         ndr->depth--;
13194         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13195         ndr->depth++;
13196         if (r->default_datatype) {
13197                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13198         }
13199         ndr->depth--;
13200         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13201         ndr->depth++;
13202         if (r->previous_names) {
13203                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13204         }
13205         ndr->depth--;
13206         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13207         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13208         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13209         ndr->depth++;
13210         if (r->manufacturer_name) {
13211                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13212         }
13213         ndr->depth--;
13214         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13215         ndr->depth++;
13216         if (r->manufacturer_url) {
13217                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13218         }
13219         ndr->depth--;
13220         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13221         ndr->depth++;
13222         if (r->hardware_id) {
13223                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13224         }
13225         ndr->depth--;
13226         ndr_print_ptr(ndr, "provider", r->provider);
13227         ndr->depth++;
13228         if (r->provider) {
13229                 ndr_print_string(ndr, "provider", r->provider);
13230         }
13231         ndr->depth--;
13232         ndr->depth--;
13233 }
13234
13235 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13236 {
13237         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13238 }
13239
13240 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
13241 {
13242         if (ndr_flags & NDR_SCALARS) {
13243                 NDR_CHECK(ndr_push_align(ndr, 5));
13244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13245                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13246                 {
13247                         uint32_t _flags_save_string = ndr->flags;
13248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13249                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13250                         ndr->flags = _flags_save_string;
13251                 }
13252                 {
13253                         uint32_t _flags_save_string = ndr->flags;
13254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13255                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
13256                         ndr->flags = _flags_save_string;
13257                 }
13258                 {
13259                         uint32_t _flags_save_string = ndr->flags;
13260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13261                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
13262                         ndr->flags = _flags_save_string;
13263                 }
13264                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13265         }
13266         if (ndr_flags & NDR_BUFFERS) {
13267                 {
13268                         uint32_t _flags_save_string = ndr->flags;
13269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13270                         if (r->driver_name) {
13271                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13273                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13274                         }
13275                         ndr->flags = _flags_save_string;
13276                 }
13277                 {
13278                         uint32_t _flags_save_string = ndr->flags;
13279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13280                         if (r->inf_name) {
13281                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_name));
13282                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
13283                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_name));
13284                         }
13285                         ndr->flags = _flags_save_string;
13286                 }
13287                 {
13288                         uint32_t _flags_save_string = ndr->flags;
13289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13290                         if (r->install_source_root) {
13291                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->install_source_root));
13292                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
13293                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->install_source_root));
13294                         }
13295                         ndr->flags = _flags_save_string;
13296                 }
13297         }
13298         return NDR_ERR_SUCCESS;
13299 }
13300
13301 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
13302 {
13303         uint32_t _ptr_driver_name;
13304         TALLOC_CTX *_mem_save_driver_name_0;
13305         uint32_t _ptr_inf_name;
13306         TALLOC_CTX *_mem_save_inf_name_0;
13307         uint32_t _ptr_install_source_root;
13308         TALLOC_CTX *_mem_save_install_source_root_0;
13309         if (ndr_flags & NDR_SCALARS) {
13310                 NDR_CHECK(ndr_pull_align(ndr, 5));
13311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13312                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13313                 {
13314                         uint32_t _flags_save_string = ndr->flags;
13315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13316                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13317                         if (_ptr_driver_name) {
13318                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13319                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13320                         } else {
13321                                 r->driver_name = NULL;
13322                         }
13323                         ndr->flags = _flags_save_string;
13324                 }
13325                 {
13326                         uint32_t _flags_save_string = ndr->flags;
13327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13328                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13329                         if (_ptr_inf_name) {
13330                                 NDR_PULL_ALLOC(ndr, r->inf_name);
13331                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13332                         } else {
13333                                 r->inf_name = NULL;
13334                         }
13335                         ndr->flags = _flags_save_string;
13336                 }
13337                 {
13338                         uint32_t _flags_save_string = ndr->flags;
13339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13340                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13341                         if (_ptr_install_source_root) {
13342                                 NDR_PULL_ALLOC(ndr, r->install_source_root);
13343                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13344                         } else {
13345                                 r->install_source_root = NULL;
13346                         }
13347                         ndr->flags = _flags_save_string;
13348                 }
13349                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13350         }
13351         if (ndr_flags & NDR_BUFFERS) {
13352                 {
13353                         uint32_t _flags_save_string = ndr->flags;
13354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13355                         if (r->driver_name) {
13356                                 uint32_t _relative_save_offset;
13357                                 _relative_save_offset = ndr->offset;
13358                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13359                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13360                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13361                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13362                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13363                                 if (ndr->offset > ndr->relative_highest_offset) {
13364                                         ndr->relative_highest_offset = ndr->offset;
13365                                 }
13366                                 ndr->offset = _relative_save_offset;
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->inf_name) {
13374                                 uint32_t _relative_save_offset;
13375                                 _relative_save_offset = ndr->offset;
13376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13377                                 _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13378                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13379                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13381                                 if (ndr->offset > ndr->relative_highest_offset) {
13382                                         ndr->relative_highest_offset = ndr->offset;
13383                                 }
13384                                 ndr->offset = _relative_save_offset;
13385                         }
13386                         ndr->flags = _flags_save_string;
13387                 }
13388                 {
13389                         uint32_t _flags_save_string = ndr->flags;
13390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13391                         if (r->install_source_root) {
13392                                 uint32_t _relative_save_offset;
13393                                 _relative_save_offset = ndr->offset;
13394                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13395                                 _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13396                                 NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13397                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13398                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13399                                 if (ndr->offset > ndr->relative_highest_offset) {
13400                                         ndr->relative_highest_offset = ndr->offset;
13401                                 }
13402                                 ndr->offset = _relative_save_offset;
13403                         }
13404                         ndr->flags = _flags_save_string;
13405                 }
13406         }
13407         return NDR_ERR_SUCCESS;
13408 }
13409
13410 _PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13411 {
13412         ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13413         ndr->depth++;
13414         ndr_print_uint32(ndr, "size", r->size);
13415         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13416         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13417         ndr->depth++;
13418         if (r->driver_name) {
13419                 ndr_print_string(ndr, "driver_name", r->driver_name);
13420         }
13421         ndr->depth--;
13422         ndr_print_ptr(ndr, "inf_name", r->inf_name);
13423         ndr->depth++;
13424         if (r->inf_name) {
13425                 ndr_print_string(ndr, "inf_name", r->inf_name);
13426         }
13427         ndr->depth--;
13428         ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13429         ndr->depth++;
13430         if (r->install_source_root) {
13431                 ndr_print_string(ndr, "install_source_root", r->install_source_root);
13432         }
13433         ndr->depth--;
13434         ndr->depth--;
13435 }
13436
13437 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13438 {
13439         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13440 }
13441
13442 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13443 {
13444         if (ndr_flags & NDR_SCALARS) {
13445                 NDR_CHECK(ndr_push_align(ndr, 8));
13446                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13447                 {
13448                         uint32_t _flags_save_string = ndr->flags;
13449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13450                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13451                         ndr->flags = _flags_save_string;
13452                 }
13453                 {
13454                         uint32_t _flags_save_string = ndr->flags;
13455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13456                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13457                         ndr->flags = _flags_save_string;
13458                 }
13459                 {
13460                         uint32_t _flags_save_string = ndr->flags;
13461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13462                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13463                         ndr->flags = _flags_save_string;
13464                 }
13465                 {
13466                         uint32_t _flags_save_string = ndr->flags;
13467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13468                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13469                         ndr->flags = _flags_save_string;
13470                 }
13471                 {
13472                         uint32_t _flags_save_string = ndr->flags;
13473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13474                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13475                         ndr->flags = _flags_save_string;
13476                 }
13477                 {
13478                         uint32_t _flags_save_string = ndr->flags;
13479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13481                         ndr->flags = _flags_save_string;
13482                 }
13483                 {
13484                         uint32_t _flags_save_string_array = ndr->flags;
13485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13487                         ndr->flags = _flags_save_string_array;
13488                 }
13489                 {
13490                         uint32_t _flags_save_string = ndr->flags;
13491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13493                         ndr->flags = _flags_save_string;
13494                 }
13495                 {
13496                         uint32_t _flags_save_string = ndr->flags;
13497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13499                         ndr->flags = _flags_save_string;
13500                 }
13501                 {
13502                         uint32_t _flags_save_string_array = ndr->flags;
13503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13505                         ndr->flags = _flags_save_string_array;
13506                 }
13507                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13508                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13509                 {
13510                         uint32_t _flags_save_string = ndr->flags;
13511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13512                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13513                         ndr->flags = _flags_save_string;
13514                 }
13515                 {
13516                         uint32_t _flags_save_string = ndr->flags;
13517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13518                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13519                         ndr->flags = _flags_save_string;
13520                 }
13521                 {
13522                         uint32_t _flags_save_string = ndr->flags;
13523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13524                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13525                         ndr->flags = _flags_save_string;
13526                 }
13527                 {
13528                         uint32_t _flags_save_string = ndr->flags;
13529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13530                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13531                         ndr->flags = _flags_save_string;
13532                 }
13533                 {
13534                         uint32_t _flags_save_string = ndr->flags;
13535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13536                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13537                         ndr->flags = _flags_save_string;
13538                 }
13539                 {
13540                         uint32_t _flags_save_string = ndr->flags;
13541                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13542                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13543                         ndr->flags = _flags_save_string;
13544                 }
13545                 {
13546                         uint32_t _flags_save_string_array = ndr->flags;
13547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13548                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13549                         ndr->flags = _flags_save_string_array;
13550                 }
13551                 {
13552                         uint32_t _flags_save_string = ndr->flags;
13553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13554                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13555                         ndr->flags = _flags_save_string;
13556                 }
13557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13558                 {
13559                         uint32_t _flags_save_string_array = ndr->flags;
13560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13562                         ndr->flags = _flags_save_string_array;
13563                 }
13564                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13565                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13566                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13567         }
13568         if (ndr_flags & NDR_BUFFERS) {
13569                 {
13570                         uint32_t _flags_save_string = ndr->flags;
13571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13572                         if (r->driver_name) {
13573                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13574                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13575                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13576                         }
13577                         ndr->flags = _flags_save_string;
13578                 }
13579                 {
13580                         uint32_t _flags_save_string = ndr->flags;
13581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13582                         if (r->architecture) {
13583                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
13584                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13585                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
13586                         }
13587                         ndr->flags = _flags_save_string;
13588                 }
13589                 {
13590                         uint32_t _flags_save_string = ndr->flags;
13591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13592                         if (r->driver_path) {
13593                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
13594                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13595                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
13596                         }
13597                         ndr->flags = _flags_save_string;
13598                 }
13599                 {
13600                         uint32_t _flags_save_string = ndr->flags;
13601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13602                         if (r->data_file) {
13603                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
13604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13605                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
13606                         }
13607                         ndr->flags = _flags_save_string;
13608                 }
13609                 {
13610                         uint32_t _flags_save_string = ndr->flags;
13611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13612                         if (r->config_file) {
13613                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
13614                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13615                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
13616                         }
13617                         ndr->flags = _flags_save_string;
13618                 }
13619                 {
13620                         uint32_t _flags_save_string = ndr->flags;
13621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13622                         if (r->help_file) {
13623                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
13624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13625                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
13626                         }
13627                         ndr->flags = _flags_save_string;
13628                 }
13629                 {
13630                         uint32_t _flags_save_string_array = ndr->flags;
13631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13632                         if (r->dependent_files) {
13633                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
13634                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13635                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
13636                         }
13637                         ndr->flags = _flags_save_string_array;
13638                 }
13639                 {
13640                         uint32_t _flags_save_string = ndr->flags;
13641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13642                         if (r->monitor_name) {
13643                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
13644                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13645                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
13646                         }
13647                         ndr->flags = _flags_save_string;
13648                 }
13649                 {
13650                         uint32_t _flags_save_string = ndr->flags;
13651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13652                         if (r->default_datatype) {
13653                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
13654                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13655                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
13656                         }
13657                         ndr->flags = _flags_save_string;
13658                 }
13659                 {
13660                         uint32_t _flags_save_string_array = ndr->flags;
13661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13662                         if (r->previous_names) {
13663                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
13664                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13665                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
13666                         }
13667                         ndr->flags = _flags_save_string_array;
13668                 }
13669                 {
13670                         uint32_t _flags_save_string = ndr->flags;
13671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13672                         if (r->manufacturer_name) {
13673                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
13674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13675                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
13676                         }
13677                         ndr->flags = _flags_save_string;
13678                 }
13679                 {
13680                         uint32_t _flags_save_string = ndr->flags;
13681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13682                         if (r->manufacturer_url) {
13683                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
13684                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13685                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
13686                         }
13687                         ndr->flags = _flags_save_string;
13688                 }
13689                 {
13690                         uint32_t _flags_save_string = ndr->flags;
13691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13692                         if (r->hardware_id) {
13693                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
13694                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13695                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
13696                         }
13697                         ndr->flags = _flags_save_string;
13698                 }
13699                 {
13700                         uint32_t _flags_save_string = ndr->flags;
13701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13702                         if (r->provider) {
13703                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
13704                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13705                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
13706                         }
13707                         ndr->flags = _flags_save_string;
13708                 }
13709                 {
13710                         uint32_t _flags_save_string = ndr->flags;
13711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13712                         if (r->print_processor) {
13713                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
13714                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13715                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
13716                         }
13717                         ndr->flags = _flags_save_string;
13718                 }
13719                 {
13720                         uint32_t _flags_save_string = ndr->flags;
13721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13722                         if (r->vendor_setup) {
13723                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->vendor_setup));
13724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13725                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->vendor_setup));
13726                         }
13727                         ndr->flags = _flags_save_string;
13728                 }
13729                 {
13730                         uint32_t _flags_save_string_array = ndr->flags;
13731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13732                         if (r->color_profiles) {
13733                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->color_profiles));
13734                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13735                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->color_profiles));
13736                         }
13737                         ndr->flags = _flags_save_string_array;
13738                 }
13739                 {
13740                         uint32_t _flags_save_string = ndr->flags;
13741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13742                         if (r->inf_path) {
13743                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_path));
13744                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13745                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_path));
13746                         }
13747                         ndr->flags = _flags_save_string;
13748                 }
13749                 {
13750                         uint32_t _flags_save_string_array = ndr->flags;
13751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13752                         if (r->core_driver_dependencies) {
13753                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->core_driver_dependencies));
13754                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13755                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->core_driver_dependencies));
13756                         }
13757                         ndr->flags = _flags_save_string_array;
13758                 }
13759         }
13760         return NDR_ERR_SUCCESS;
13761 }
13762
13763 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13764 {
13765         uint32_t _ptr_driver_name;
13766         TALLOC_CTX *_mem_save_driver_name_0;
13767         uint32_t _ptr_architecture;
13768         TALLOC_CTX *_mem_save_architecture_0;
13769         uint32_t _ptr_driver_path;
13770         TALLOC_CTX *_mem_save_driver_path_0;
13771         uint32_t _ptr_data_file;
13772         TALLOC_CTX *_mem_save_data_file_0;
13773         uint32_t _ptr_config_file;
13774         TALLOC_CTX *_mem_save_config_file_0;
13775         uint32_t _ptr_help_file;
13776         TALLOC_CTX *_mem_save_help_file_0;
13777         uint32_t _ptr_dependent_files;
13778         TALLOC_CTX *_mem_save_dependent_files_0;
13779         uint32_t _ptr_monitor_name;
13780         TALLOC_CTX *_mem_save_monitor_name_0;
13781         uint32_t _ptr_default_datatype;
13782         TALLOC_CTX *_mem_save_default_datatype_0;
13783         uint32_t _ptr_previous_names;
13784         TALLOC_CTX *_mem_save_previous_names_0;
13785         uint32_t _ptr_manufacturer_name;
13786         TALLOC_CTX *_mem_save_manufacturer_name_0;
13787         uint32_t _ptr_manufacturer_url;
13788         TALLOC_CTX *_mem_save_manufacturer_url_0;
13789         uint32_t _ptr_hardware_id;
13790         TALLOC_CTX *_mem_save_hardware_id_0;
13791         uint32_t _ptr_provider;
13792         TALLOC_CTX *_mem_save_provider_0;
13793         uint32_t _ptr_print_processor;
13794         TALLOC_CTX *_mem_save_print_processor_0;
13795         uint32_t _ptr_vendor_setup;
13796         TALLOC_CTX *_mem_save_vendor_setup_0;
13797         uint32_t _ptr_color_profiles;
13798         TALLOC_CTX *_mem_save_color_profiles_0;
13799         uint32_t _ptr_inf_path;
13800         TALLOC_CTX *_mem_save_inf_path_0;
13801         uint32_t _ptr_core_driver_dependencies;
13802         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13803         if (ndr_flags & NDR_SCALARS) {
13804                 NDR_CHECK(ndr_pull_align(ndr, 8));
13805                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13806                 {
13807                         uint32_t _flags_save_string = ndr->flags;
13808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13809                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13810                         if (_ptr_driver_name) {
13811                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13812                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13813                         } else {
13814                                 r->driver_name = NULL;
13815                         }
13816                         ndr->flags = _flags_save_string;
13817                 }
13818                 {
13819                         uint32_t _flags_save_string = ndr->flags;
13820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13821                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13822                         if (_ptr_architecture) {
13823                                 NDR_PULL_ALLOC(ndr, r->architecture);
13824                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13825                         } else {
13826                                 r->architecture = NULL;
13827                         }
13828                         ndr->flags = _flags_save_string;
13829                 }
13830                 {
13831                         uint32_t _flags_save_string = ndr->flags;
13832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13834                         if (_ptr_driver_path) {
13835                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13837                         } else {
13838                                 r->driver_path = NULL;
13839                         }
13840                         ndr->flags = _flags_save_string;
13841                 }
13842                 {
13843                         uint32_t _flags_save_string = ndr->flags;
13844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13845                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13846                         if (_ptr_data_file) {
13847                                 NDR_PULL_ALLOC(ndr, r->data_file);
13848                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13849                         } else {
13850                                 r->data_file = NULL;
13851                         }
13852                         ndr->flags = _flags_save_string;
13853                 }
13854                 {
13855                         uint32_t _flags_save_string = ndr->flags;
13856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13857                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13858                         if (_ptr_config_file) {
13859                                 NDR_PULL_ALLOC(ndr, r->config_file);
13860                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13861                         } else {
13862                                 r->config_file = NULL;
13863                         }
13864                         ndr->flags = _flags_save_string;
13865                 }
13866                 {
13867                         uint32_t _flags_save_string = ndr->flags;
13868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13869                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13870                         if (_ptr_help_file) {
13871                                 NDR_PULL_ALLOC(ndr, r->help_file);
13872                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13873                         } else {
13874                                 r->help_file = NULL;
13875                         }
13876                         ndr->flags = _flags_save_string;
13877                 }
13878                 {
13879                         uint32_t _flags_save_string_array = ndr->flags;
13880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13881                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13882                         if (_ptr_dependent_files) {
13883                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13884                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13885                         } else {
13886                                 r->dependent_files = NULL;
13887                         }
13888                         ndr->flags = _flags_save_string_array;
13889                 }
13890                 {
13891                         uint32_t _flags_save_string = ndr->flags;
13892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13893                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13894                         if (_ptr_monitor_name) {
13895                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13896                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13897                         } else {
13898                                 r->monitor_name = NULL;
13899                         }
13900                         ndr->flags = _flags_save_string;
13901                 }
13902                 {
13903                         uint32_t _flags_save_string = ndr->flags;
13904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13905                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13906                         if (_ptr_default_datatype) {
13907                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13908                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13909                         } else {
13910                                 r->default_datatype = NULL;
13911                         }
13912                         ndr->flags = _flags_save_string;
13913                 }
13914                 {
13915                         uint32_t _flags_save_string_array = ndr->flags;
13916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13917                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13918                         if (_ptr_previous_names) {
13919                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13920                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13921                         } else {
13922                                 r->previous_names = NULL;
13923                         }
13924                         ndr->flags = _flags_save_string_array;
13925                 }
13926                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13927                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13928                 {
13929                         uint32_t _flags_save_string = ndr->flags;
13930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13931                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13932                         if (_ptr_manufacturer_name) {
13933                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13934                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13935                         } else {
13936                                 r->manufacturer_name = NULL;
13937                         }
13938                         ndr->flags = _flags_save_string;
13939                 }
13940                 {
13941                         uint32_t _flags_save_string = ndr->flags;
13942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13943                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13944                         if (_ptr_manufacturer_url) {
13945                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13946                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13947                         } else {
13948                                 r->manufacturer_url = NULL;
13949                         }
13950                         ndr->flags = _flags_save_string;
13951                 }
13952                 {
13953                         uint32_t _flags_save_string = ndr->flags;
13954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13955                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13956                         if (_ptr_hardware_id) {
13957                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13958                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13959                         } else {
13960                                 r->hardware_id = NULL;
13961                         }
13962                         ndr->flags = _flags_save_string;
13963                 }
13964                 {
13965                         uint32_t _flags_save_string = ndr->flags;
13966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13967                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13968                         if (_ptr_provider) {
13969                                 NDR_PULL_ALLOC(ndr, r->provider);
13970                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13971                         } else {
13972                                 r->provider = NULL;
13973                         }
13974                         ndr->flags = _flags_save_string;
13975                 }
13976                 {
13977                         uint32_t _flags_save_string = ndr->flags;
13978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13979                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13980                         if (_ptr_print_processor) {
13981                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13982                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13983                         } else {
13984                                 r->print_processor = NULL;
13985                         }
13986                         ndr->flags = _flags_save_string;
13987                 }
13988                 {
13989                         uint32_t _flags_save_string = ndr->flags;
13990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13991                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13992                         if (_ptr_vendor_setup) {
13993                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13994                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13995                         } else {
13996                                 r->vendor_setup = NULL;
13997                         }
13998                         ndr->flags = _flags_save_string;
13999                 }
14000                 {
14001                         uint32_t _flags_save_string_array = ndr->flags;
14002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14003                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
14004                         if (_ptr_color_profiles) {
14005                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
14006                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
14007                         } else {
14008                                 r->color_profiles = NULL;
14009                         }
14010                         ndr->flags = _flags_save_string_array;
14011                 }
14012                 {
14013                         uint32_t _flags_save_string = ndr->flags;
14014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14015                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
14016                         if (_ptr_inf_path) {
14017                                 NDR_PULL_ALLOC(ndr, r->inf_path);
14018                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
14019                         } else {
14020                                 r->inf_path = NULL;
14021                         }
14022                         ndr->flags = _flags_save_string;
14023                 }
14024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
14025                 {
14026                         uint32_t _flags_save_string_array = ndr->flags;
14027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14028                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
14029                         if (_ptr_core_driver_dependencies) {
14030                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
14031                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
14032                         } else {
14033                                 r->core_driver_dependencies = NULL;
14034                         }
14035                         ndr->flags = _flags_save_string_array;
14036                 }
14037                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
14038                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
14039                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
14040         }
14041         if (ndr_flags & NDR_BUFFERS) {
14042                 {
14043                         uint32_t _flags_save_string = ndr->flags;
14044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14045                         if (r->driver_name) {
14046                                 uint32_t _relative_save_offset;
14047                                 _relative_save_offset = ndr->offset;
14048                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
14049                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14050                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
14051                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
14052                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
14053                                 if (ndr->offset > ndr->relative_highest_offset) {
14054                                         ndr->relative_highest_offset = ndr->offset;
14055                                 }
14056                                 ndr->offset = _relative_save_offset;
14057                         }
14058                         ndr->flags = _flags_save_string;
14059                 }
14060                 {
14061                         uint32_t _flags_save_string = ndr->flags;
14062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14063                         if (r->architecture) {
14064                                 uint32_t _relative_save_offset;
14065                                 _relative_save_offset = ndr->offset;
14066                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
14067                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
14068                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
14069                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
14070                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
14071                                 if (ndr->offset > ndr->relative_highest_offset) {
14072                                         ndr->relative_highest_offset = ndr->offset;
14073                                 }
14074                                 ndr->offset = _relative_save_offset;
14075                         }
14076                         ndr->flags = _flags_save_string;
14077                 }
14078                 {
14079                         uint32_t _flags_save_string = ndr->flags;
14080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14081                         if (r->driver_path) {
14082                                 uint32_t _relative_save_offset;
14083                                 _relative_save_offset = ndr->offset;
14084                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
14085                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14086                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
14087                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
14088                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
14089                                 if (ndr->offset > ndr->relative_highest_offset) {
14090                                         ndr->relative_highest_offset = ndr->offset;
14091                                 }
14092                                 ndr->offset = _relative_save_offset;
14093                         }
14094                         ndr->flags = _flags_save_string;
14095                 }
14096                 {
14097                         uint32_t _flags_save_string = ndr->flags;
14098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14099                         if (r->data_file) {
14100                                 uint32_t _relative_save_offset;
14101                                 _relative_save_offset = ndr->offset;
14102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
14103                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14104                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
14105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
14106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
14107                                 if (ndr->offset > ndr->relative_highest_offset) {
14108                                         ndr->relative_highest_offset = ndr->offset;
14109                                 }
14110                                 ndr->offset = _relative_save_offset;
14111                         }
14112                         ndr->flags = _flags_save_string;
14113                 }
14114                 {
14115                         uint32_t _flags_save_string = ndr->flags;
14116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14117                         if (r->config_file) {
14118                                 uint32_t _relative_save_offset;
14119                                 _relative_save_offset = ndr->offset;
14120                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
14121                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14122                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
14123                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
14124                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
14125                                 if (ndr->offset > ndr->relative_highest_offset) {
14126                                         ndr->relative_highest_offset = ndr->offset;
14127                                 }
14128                                 ndr->offset = _relative_save_offset;
14129                         }
14130                         ndr->flags = _flags_save_string;
14131                 }
14132                 {
14133                         uint32_t _flags_save_string = ndr->flags;
14134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14135                         if (r->help_file) {
14136                                 uint32_t _relative_save_offset;
14137                                 _relative_save_offset = ndr->offset;
14138                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
14139                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14140                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
14141                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
14142                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
14143                                 if (ndr->offset > ndr->relative_highest_offset) {
14144                                         ndr->relative_highest_offset = ndr->offset;
14145                                 }
14146                                 ndr->offset = _relative_save_offset;
14147                         }
14148                         ndr->flags = _flags_save_string;
14149                 }
14150                 {
14151                         uint32_t _flags_save_string_array = ndr->flags;
14152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14153                         if (r->dependent_files) {
14154                                 uint32_t _relative_save_offset;
14155                                 _relative_save_offset = ndr->offset;
14156                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
14157                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
14158                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
14159                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
14160                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
14161                                 if (ndr->offset > ndr->relative_highest_offset) {
14162                                         ndr->relative_highest_offset = ndr->offset;
14163                                 }
14164                                 ndr->offset = _relative_save_offset;
14165                         }
14166                         ndr->flags = _flags_save_string_array;
14167                 }
14168                 {
14169                         uint32_t _flags_save_string = ndr->flags;
14170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14171                         if (r->monitor_name) {
14172                                 uint32_t _relative_save_offset;
14173                                 _relative_save_offset = ndr->offset;
14174                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14175                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14176                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14177                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14178                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14179                                 if (ndr->offset > ndr->relative_highest_offset) {
14180                                         ndr->relative_highest_offset = ndr->offset;
14181                                 }
14182                                 ndr->offset = _relative_save_offset;
14183                         }
14184                         ndr->flags = _flags_save_string;
14185                 }
14186                 {
14187                         uint32_t _flags_save_string = ndr->flags;
14188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14189                         if (r->default_datatype) {
14190                                 uint32_t _relative_save_offset;
14191                                 _relative_save_offset = ndr->offset;
14192                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
14193                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14194                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
14195                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
14196                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
14197                                 if (ndr->offset > ndr->relative_highest_offset) {
14198                                         ndr->relative_highest_offset = ndr->offset;
14199                                 }
14200                                 ndr->offset = _relative_save_offset;
14201                         }
14202                         ndr->flags = _flags_save_string;
14203                 }
14204                 {
14205                         uint32_t _flags_save_string_array = ndr->flags;
14206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14207                         if (r->previous_names) {
14208                                 uint32_t _relative_save_offset;
14209                                 _relative_save_offset = ndr->offset;
14210                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
14211                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
14212                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
14213                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
14214                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
14215                                 if (ndr->offset > ndr->relative_highest_offset) {
14216                                         ndr->relative_highest_offset = ndr->offset;
14217                                 }
14218                                 ndr->offset = _relative_save_offset;
14219                         }
14220                         ndr->flags = _flags_save_string_array;
14221                 }
14222                 {
14223                         uint32_t _flags_save_string = ndr->flags;
14224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14225                         if (r->manufacturer_name) {
14226                                 uint32_t _relative_save_offset;
14227                                 _relative_save_offset = ndr->offset;
14228                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
14229                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14230                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
14231                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
14232                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
14233                                 if (ndr->offset > ndr->relative_highest_offset) {
14234                                         ndr->relative_highest_offset = ndr->offset;
14235                                 }
14236                                 ndr->offset = _relative_save_offset;
14237                         }
14238                         ndr->flags = _flags_save_string;
14239                 }
14240                 {
14241                         uint32_t _flags_save_string = ndr->flags;
14242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14243                         if (r->manufacturer_url) {
14244                                 uint32_t _relative_save_offset;
14245                                 _relative_save_offset = ndr->offset;
14246                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
14247                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
14248                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
14249                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
14250                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
14251                                 if (ndr->offset > ndr->relative_highest_offset) {
14252                                         ndr->relative_highest_offset = ndr->offset;
14253                                 }
14254                                 ndr->offset = _relative_save_offset;
14255                         }
14256                         ndr->flags = _flags_save_string;
14257                 }
14258                 {
14259                         uint32_t _flags_save_string = ndr->flags;
14260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14261                         if (r->hardware_id) {
14262                                 uint32_t _relative_save_offset;
14263                                 _relative_save_offset = ndr->offset;
14264                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
14265                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14266                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
14267                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
14268                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
14269                                 if (ndr->offset > ndr->relative_highest_offset) {
14270                                         ndr->relative_highest_offset = ndr->offset;
14271                                 }
14272                                 ndr->offset = _relative_save_offset;
14273                         }
14274                         ndr->flags = _flags_save_string;
14275                 }
14276                 {
14277                         uint32_t _flags_save_string = ndr->flags;
14278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14279                         if (r->provider) {
14280                                 uint32_t _relative_save_offset;
14281                                 _relative_save_offset = ndr->offset;
14282                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
14283                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
14284                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
14285                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
14286                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
14287                                 if (ndr->offset > ndr->relative_highest_offset) {
14288                                         ndr->relative_highest_offset = ndr->offset;
14289                                 }
14290                                 ndr->offset = _relative_save_offset;
14291                         }
14292                         ndr->flags = _flags_save_string;
14293                 }
14294                 {
14295                         uint32_t _flags_save_string = ndr->flags;
14296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14297                         if (r->print_processor) {
14298                                 uint32_t _relative_save_offset;
14299                                 _relative_save_offset = ndr->offset;
14300                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
14301                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
14302                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
14303                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
14304                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
14305                                 if (ndr->offset > ndr->relative_highest_offset) {
14306                                         ndr->relative_highest_offset = ndr->offset;
14307                                 }
14308                                 ndr->offset = _relative_save_offset;
14309                         }
14310                         ndr->flags = _flags_save_string;
14311                 }
14312                 {
14313                         uint32_t _flags_save_string = ndr->flags;
14314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14315                         if (r->vendor_setup) {
14316                                 uint32_t _relative_save_offset;
14317                                 _relative_save_offset = ndr->offset;
14318                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14319                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14320                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14321                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14322                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14323                                 if (ndr->offset > ndr->relative_highest_offset) {
14324                                         ndr->relative_highest_offset = ndr->offset;
14325                                 }
14326                                 ndr->offset = _relative_save_offset;
14327                         }
14328                         ndr->flags = _flags_save_string;
14329                 }
14330                 {
14331                         uint32_t _flags_save_string_array = ndr->flags;
14332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14333                         if (r->color_profiles) {
14334                                 uint32_t _relative_save_offset;
14335                                 _relative_save_offset = ndr->offset;
14336                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14337                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14338                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14339                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14340                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14341                                 if (ndr->offset > ndr->relative_highest_offset) {
14342                                         ndr->relative_highest_offset = ndr->offset;
14343                                 }
14344                                 ndr->offset = _relative_save_offset;
14345                         }
14346                         ndr->flags = _flags_save_string_array;
14347                 }
14348                 {
14349                         uint32_t _flags_save_string = ndr->flags;
14350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14351                         if (r->inf_path) {
14352                                 uint32_t _relative_save_offset;
14353                                 _relative_save_offset = ndr->offset;
14354                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14355                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14356                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14357                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14358                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14359                                 if (ndr->offset > ndr->relative_highest_offset) {
14360                                         ndr->relative_highest_offset = ndr->offset;
14361                                 }
14362                                 ndr->offset = _relative_save_offset;
14363                         }
14364                         ndr->flags = _flags_save_string;
14365                 }
14366                 {
14367                         uint32_t _flags_save_string_array = ndr->flags;
14368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14369                         if (r->core_driver_dependencies) {
14370                                 uint32_t _relative_save_offset;
14371                                 _relative_save_offset = ndr->offset;
14372                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14373                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14374                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14375                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14376                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14377                                 if (ndr->offset > ndr->relative_highest_offset) {
14378                                         ndr->relative_highest_offset = ndr->offset;
14379                                 }
14380                                 ndr->offset = _relative_save_offset;
14381                         }
14382                         ndr->flags = _flags_save_string_array;
14383                 }
14384         }
14385         return NDR_ERR_SUCCESS;
14386 }
14387
14388 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14389 {
14390         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14391         ndr->depth++;
14392         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14393         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14394         ndr->depth++;
14395         if (r->driver_name) {
14396                 ndr_print_string(ndr, "driver_name", r->driver_name);
14397         }
14398         ndr->depth--;
14399         ndr_print_ptr(ndr, "architecture", r->architecture);
14400         ndr->depth++;
14401         if (r->architecture) {
14402                 ndr_print_string(ndr, "architecture", r->architecture);
14403         }
14404         ndr->depth--;
14405         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14406         ndr->depth++;
14407         if (r->driver_path) {
14408                 ndr_print_string(ndr, "driver_path", r->driver_path);
14409         }
14410         ndr->depth--;
14411         ndr_print_ptr(ndr, "data_file", r->data_file);
14412         ndr->depth++;
14413         if (r->data_file) {
14414                 ndr_print_string(ndr, "data_file", r->data_file);
14415         }
14416         ndr->depth--;
14417         ndr_print_ptr(ndr, "config_file", r->config_file);
14418         ndr->depth++;
14419         if (r->config_file) {
14420                 ndr_print_string(ndr, "config_file", r->config_file);
14421         }
14422         ndr->depth--;
14423         ndr_print_ptr(ndr, "help_file", r->help_file);
14424         ndr->depth++;
14425         if (r->help_file) {
14426                 ndr_print_string(ndr, "help_file", r->help_file);
14427         }
14428         ndr->depth--;
14429         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14430         ndr->depth++;
14431         if (r->dependent_files) {
14432                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14433         }
14434         ndr->depth--;
14435         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14436         ndr->depth++;
14437         if (r->monitor_name) {
14438                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14439         }
14440         ndr->depth--;
14441         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14442         ndr->depth++;
14443         if (r->default_datatype) {
14444                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14445         }
14446         ndr->depth--;
14447         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14448         ndr->depth++;
14449         if (r->previous_names) {
14450                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14451         }
14452         ndr->depth--;
14453         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14454         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14455         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14456         ndr->depth++;
14457         if (r->manufacturer_name) {
14458                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14459         }
14460         ndr->depth--;
14461         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14462         ndr->depth++;
14463         if (r->manufacturer_url) {
14464                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14465         }
14466         ndr->depth--;
14467         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14468         ndr->depth++;
14469         if (r->hardware_id) {
14470                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14471         }
14472         ndr->depth--;
14473         ndr_print_ptr(ndr, "provider", r->provider);
14474         ndr->depth++;
14475         if (r->provider) {
14476                 ndr_print_string(ndr, "provider", r->provider);
14477         }
14478         ndr->depth--;
14479         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14480         ndr->depth++;
14481         if (r->print_processor) {
14482                 ndr_print_string(ndr, "print_processor", r->print_processor);
14483         }
14484         ndr->depth--;
14485         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14486         ndr->depth++;
14487         if (r->vendor_setup) {
14488                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14489         }
14490         ndr->depth--;
14491         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14492         ndr->depth++;
14493         if (r->color_profiles) {
14494                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14495         }
14496         ndr->depth--;
14497         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14498         ndr->depth++;
14499         if (r->inf_path) {
14500                 ndr_print_string(ndr, "inf_path", r->inf_path);
14501         }
14502         ndr->depth--;
14503         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14504         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14505         ndr->depth++;
14506         if (r->core_driver_dependencies) {
14507                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14508         }
14509         ndr->depth--;
14510         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14511         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14512         ndr->depth--;
14513 }
14514
14515 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14516 {
14517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14518 }
14519
14520 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14521 {
14522         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14523         return NDR_ERR_SUCCESS;
14524 }
14525
14526 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14527 {
14528         uint32_t v;
14529         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14530         *r = v;
14531         return NDR_ERR_SUCCESS;
14532 }
14533
14534 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14535 {
14536         const char *val = NULL;
14537
14538         switch (r) {
14539                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14540                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14541                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14542                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14543                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14544         }
14545         ndr_print_enum(ndr, name, "ENUM", val, r);
14546 }
14547
14548 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14549 {
14550         if (ndr_flags & NDR_SCALARS) {
14551                 NDR_CHECK(ndr_push_align(ndr, 5));
14552                 {
14553                         uint32_t _flags_save_string = ndr->flags;
14554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14556                         ndr->flags = _flags_save_string;
14557                 }
14558                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14560                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14561         }
14562         if (ndr_flags & NDR_BUFFERS) {
14563                 {
14564                         uint32_t _flags_save_string = ndr->flags;
14565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14566                         if (r->file_name) {
14567                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_name));
14568                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14569                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_name));
14570                         }
14571                         ndr->flags = _flags_save_string;
14572                 }
14573         }
14574         return NDR_ERR_SUCCESS;
14575 }
14576
14577 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14578 {
14579         uint32_t _ptr_file_name;
14580         TALLOC_CTX *_mem_save_file_name_0;
14581         if (ndr_flags & NDR_SCALARS) {
14582                 NDR_CHECK(ndr_pull_align(ndr, 5));
14583                 {
14584                         uint32_t _flags_save_string = ndr->flags;
14585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14586                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14587                         if (_ptr_file_name) {
14588                                 NDR_PULL_ALLOC(ndr, r->file_name);
14589                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14590                         } else {
14591                                 r->file_name = NULL;
14592                         }
14593                         ndr->flags = _flags_save_string;
14594                 }
14595                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14597                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14598         }
14599         if (ndr_flags & NDR_BUFFERS) {
14600                 {
14601                         uint32_t _flags_save_string = ndr->flags;
14602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14603                         if (r->file_name) {
14604                                 uint32_t _relative_save_offset;
14605                                 _relative_save_offset = ndr->offset;
14606                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14607                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14608                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14609                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14610                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14611                                 if (ndr->offset > ndr->relative_highest_offset) {
14612                                         ndr->relative_highest_offset = ndr->offset;
14613                                 }
14614                                 ndr->offset = _relative_save_offset;
14615                         }
14616                         ndr->flags = _flags_save_string;
14617                 }
14618         }
14619         return NDR_ERR_SUCCESS;
14620 }
14621
14622 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14623 {
14624         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14625         ndr->depth++;
14626         ndr_print_ptr(ndr, "file_name", r->file_name);
14627         ndr->depth++;
14628         if (r->file_name) {
14629                 ndr_print_string(ndr, "file_name", r->file_name);
14630         }
14631         ndr->depth--;
14632         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14633         ndr_print_uint32(ndr, "file_version", r->file_version);
14634         ndr->depth--;
14635 }
14636
14637 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14638 {
14639         uint32_t cntr_file_info_1;
14640         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14641         ndr->depth++;
14642         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14643         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14644         ndr->depth++;
14645         if (r->driver_name) {
14646                 ndr_print_string(ndr, "driver_name", r->driver_name);
14647         }
14648         ndr->depth--;
14649         ndr_print_ptr(ndr, "architecture", r->architecture);
14650         ndr->depth++;
14651         if (r->architecture) {
14652                 ndr_print_string(ndr, "architecture", r->architecture);
14653         }
14654         ndr->depth--;
14655         ndr_print_ptr(ndr, "file_info", r->file_info);
14656         ndr->depth++;
14657         if (r->file_info) {
14658                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14659                 ndr->depth++;
14660                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14661                         char *idx_1=NULL;
14662                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14663                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14664                                 free(idx_1);
14665                         }
14666                 }
14667                 ndr->depth--;
14668         }
14669         ndr->depth--;
14670         ndr_print_uint32(ndr, "file_count", r->file_count);
14671         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14672         ndr->depth++;
14673         if (r->monitor_name) {
14674                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14675         }
14676         ndr->depth--;
14677         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14678         ndr->depth++;
14679         if (r->default_datatype) {
14680                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14681         }
14682         ndr->depth--;
14683         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14684         ndr->depth++;
14685         if (r->previous_names) {
14686                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14687         }
14688         ndr->depth--;
14689         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14690         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14691         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14692         ndr->depth++;
14693         if (r->manufacturer_name) {
14694                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14695         }
14696         ndr->depth--;
14697         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14698         ndr->depth++;
14699         if (r->manufacturer_url) {
14700                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14701         }
14702         ndr->depth--;
14703         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14704         ndr->depth++;
14705         if (r->hardware_id) {
14706                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14707         }
14708         ndr->depth--;
14709         ndr_print_ptr(ndr, "provider", r->provider);
14710         ndr->depth++;
14711         if (r->provider) {
14712                 ndr_print_string(ndr, "provider", r->provider);
14713         }
14714         ndr->depth--;
14715         ndr->depth--;
14716 }
14717
14718 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14719 {
14720         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14721 }
14722
14723 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14724 {
14725         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14726         {
14727                 uint32_t _flags_save_UNION = ndr->flags;
14728                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14729                 if (ndr_flags & NDR_SCALARS) {
14730                         int level = ndr_push_get_switch_value(ndr, r);
14731                         NDR_CHECK(ndr_push_union_align(ndr, 8));
14732                         switch (level) {
14733                                 case 1: {
14734                                         NDR_CHECK(ndr_push_align(ndr, 5));
14735                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14736                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14737                                 break; }
14738
14739                                 case 2: {
14740                                         NDR_CHECK(ndr_push_align(ndr, 5));
14741                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14742                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14743                                 break; }
14744
14745                                 case 3: {
14746                                         NDR_CHECK(ndr_push_align(ndr, 5));
14747                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14748                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14749                                 break; }
14750
14751                                 case 4: {
14752                                         NDR_CHECK(ndr_push_align(ndr, 5));
14753                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14754                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14755                                 break; }
14756
14757                                 case 5: {
14758                                         NDR_CHECK(ndr_push_align(ndr, 5));
14759                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14760                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14761                                 break; }
14762
14763                                 case 6: {
14764                                         NDR_CHECK(ndr_push_align(ndr, 8));
14765                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14766                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14767                                 break; }
14768
14769                                 case 7: {
14770                                         NDR_CHECK(ndr_push_align(ndr, 5));
14771                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14772                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14773                                 break; }
14774
14775                                 case 8: {
14776                                         NDR_CHECK(ndr_push_align(ndr, 8));
14777                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14778                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14779                                 break; }
14780
14781                                 case 101: {
14782                                         NDR_CHECK(ndr_push_align(ndr, 8));
14783                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14784                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14785                                 break; }
14786
14787                                 default: {
14788                                 break; }
14789
14790                         }
14791                 }
14792                 if (ndr_flags & NDR_BUFFERS) {
14793                         int level = ndr_push_get_switch_value(ndr, r);
14794                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14795                         switch (level) {
14796                                 case 1:
14797                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14798                                 break;
14799
14800                                 case 2:
14801                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14802                                 break;
14803
14804                                 case 3:
14805                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14806                                 break;
14807
14808                                 case 4:
14809                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14810                                 break;
14811
14812                                 case 5:
14813                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14814                                 break;
14815
14816                                 case 6:
14817                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14818                                 break;
14819
14820                                 case 7:
14821                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14822                                 break;
14823
14824                                 case 8:
14825                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14826                                 break;
14827
14828                                 case 101:
14829                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14830                                 break;
14831
14832                                 default:
14833                                 break;
14834
14835                         }
14836                 }
14837                 ndr->flags = _flags_save_UNION;
14838         }
14839         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14840         return NDR_ERR_SUCCESS;
14841 }
14842
14843 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14844 {
14845         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14846         int level;
14847         {
14848                 uint32_t _flags_save_UNION = ndr->flags;
14849                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14850                 level = ndr_pull_get_switch_value(ndr, r);
14851                 if (ndr_flags & NDR_SCALARS) {
14852                         NDR_CHECK(ndr_pull_union_align(ndr, 8));
14853                         switch (level) {
14854                                 case 1: {
14855                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14856                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14857                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14858                                 break; }
14859
14860                                 case 2: {
14861                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14862                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14863                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14864                                 break; }
14865
14866                                 case 3: {
14867                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14868                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14869                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14870                                 break; }
14871
14872                                 case 4: {
14873                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14874                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14875                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14876                                 break; }
14877
14878                                 case 5: {
14879                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14880                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14881                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14882                                 break; }
14883
14884                                 case 6: {
14885                                         NDR_CHECK(ndr_pull_align(ndr, 8));
14886                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14887                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14888                                 break; }
14889
14890                                 case 7: {
14891                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14892                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14893                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14894                                 break; }
14895
14896                                 case 8: {
14897                                         NDR_CHECK(ndr_pull_align(ndr, 8));
14898                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14899                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14900                                 break; }
14901
14902                                 case 101: {
14903                                         NDR_CHECK(ndr_pull_align(ndr, 8));
14904                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14905                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14906                                 break; }
14907
14908                                 default: {
14909                                 break; }
14910
14911                         }
14912                 }
14913                 if (ndr_flags & NDR_BUFFERS) {
14914                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14915                         switch (level) {
14916                                 case 1:
14917                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14918                                 break;
14919
14920                                 case 2:
14921                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14922                                 break;
14923
14924                                 case 3:
14925                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14926                                 break;
14927
14928                                 case 4:
14929                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14930                                 break;
14931
14932                                 case 5:
14933                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14934                                 break;
14935
14936                                 case 6:
14937                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14938                                 break;
14939
14940                                 case 7:
14941                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14942                                 break;
14943
14944                                 case 8:
14945                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14946                                 break;
14947
14948                                 case 101:
14949                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14950                                 break;
14951
14952                                 default:
14953                                 break;
14954
14955                         }
14956                 }
14957                 ndr->flags = _flags_save_UNION;
14958         }
14959         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14960         return NDR_ERR_SUCCESS;
14961 }
14962
14963 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14964 {
14965         int level;
14966         {
14967                 uint32_t _flags_save_UNION = ndr->flags;
14968                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14969                 level = ndr_print_get_switch_value(ndr, r);
14970                 ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14971                 switch (level) {
14972                         case 1:
14973                                 ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14974                         break;
14975
14976                         case 2:
14977                                 ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14978                         break;
14979
14980                         case 3:
14981                                 ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14982                         break;
14983
14984                         case 4:
14985                                 ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14986                         break;
14987
14988                         case 5:
14989                                 ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14990                         break;
14991
14992                         case 6:
14993                                 ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14994                         break;
14995
14996                         case 7:
14997                                 ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
14998                         break;
14999
15000                         case 8:
15001                                 ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
15002                         break;
15003
15004                         case 101:
15005                                 ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
15006                         break;
15007
15008                         default:
15009                         break;
15010
15011                 }
15012                 ndr->flags = _flags_save_UNION;
15013         }
15014 }
15015
15016 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15017 {
15018         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15019         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
15020 }
15021
15022 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
15023 {
15024         if (ndr_flags & NDR_SCALARS) {
15025                 NDR_CHECK(ndr_push_align(ndr, 4));
15026                 {
15027                         uint32_t _flags_save_string = ndr->flags;
15028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15029                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15030                         ndr->flags = _flags_save_string;
15031                 }
15032                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15033         }
15034         if (ndr_flags & NDR_BUFFERS) {
15035         }
15036         return NDR_ERR_SUCCESS;
15037 }
15038
15039 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
15040 {
15041         if (ndr_flags & NDR_SCALARS) {
15042                 NDR_CHECK(ndr_pull_align(ndr, 4));
15043                 {
15044                         uint32_t _flags_save_string = ndr->flags;
15045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15046                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15047                         ndr->flags = _flags_save_string;
15048                 }
15049                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15050         }
15051         if (ndr_flags & NDR_BUFFERS) {
15052         }
15053         return NDR_ERR_SUCCESS;
15054 }
15055
15056 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
15057 {
15058         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
15059         ndr->depth++;
15060         ndr_print_string(ndr, "directory_name", r->directory_name);
15061         ndr->depth--;
15062 }
15063
15064 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15065 {
15066         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
15067 }
15068
15069 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
15070 {
15071         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15072         {
15073                 uint32_t _flags_save_UNION = ndr->flags;
15074                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15075                 if (ndr_flags & NDR_SCALARS) {
15076                         int level = ndr_push_get_switch_value(ndr, r);
15077                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15078                         switch (level) {
15079                                 case 1: {
15080                                         NDR_CHECK(ndr_push_align(ndr, 4));
15081                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15082                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15083                                 break; }
15084
15085                                 default: {
15086                                         NDR_CHECK(ndr_push_align(ndr, 4));
15087                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15088                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15089                                 break; }
15090
15091                         }
15092                 }
15093                 if (ndr_flags & NDR_BUFFERS) {
15094                         int level = ndr_push_get_switch_value(ndr, r);
15095                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15096                         switch (level) {
15097                                 case 1:
15098                                 break;
15099
15100                                 default:
15101                                 break;
15102
15103                         }
15104                 }
15105                 ndr->flags = _flags_save_UNION;
15106         }
15107         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15108         return NDR_ERR_SUCCESS;
15109 }
15110
15111 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
15112 {
15113         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15114         int level;
15115         {
15116                 uint32_t _flags_save_UNION = ndr->flags;
15117                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15118                 level = ndr_pull_get_switch_value(ndr, r);
15119                 if (ndr_flags & NDR_SCALARS) {
15120                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15121                         switch (level) {
15122                                 case 1: {
15123                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15124                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15125                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15126                                 break; }
15127
15128                                 default: {
15129                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15130                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15131                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15132                                 break; }
15133
15134                         }
15135                 }
15136                 if (ndr_flags & NDR_BUFFERS) {
15137                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15138                         switch (level) {
15139                                 case 1:
15140                                 break;
15141
15142                                 default:
15143                                 break;
15144
15145                         }
15146                 }
15147                 ndr->flags = _flags_save_UNION;
15148         }
15149         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15150         return NDR_ERR_SUCCESS;
15151 }
15152
15153 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
15154 {
15155         int level;
15156         {
15157                 uint32_t _flags_save_UNION = ndr->flags;
15158                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15159                 level = ndr_print_get_switch_value(ndr, r);
15160                 ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
15161                 switch (level) {
15162                         case 1:
15163                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15164                         break;
15165
15166                         default:
15167                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15168                         break;
15169
15170                 }
15171                 ndr->flags = _flags_save_UNION;
15172         }
15173 }
15174
15175 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15176 {
15177         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15178         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
15179 }
15180
15181 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
15182 {
15183         if (ndr_flags & NDR_SCALARS) {
15184                 NDR_CHECK(ndr_push_align(ndr, 5));
15185                 {
15186                         uint32_t _flags_save_string = ndr->flags;
15187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15188                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
15189                         ndr->flags = _flags_save_string;
15190                 }
15191                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15192         }
15193         if (ndr_flags & NDR_BUFFERS) {
15194                 {
15195                         uint32_t _flags_save_string = ndr->flags;
15196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15197                         if (r->print_processor_name) {
15198                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor_name));
15199                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
15200                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor_name));
15201                         }
15202                         ndr->flags = _flags_save_string;
15203                 }
15204         }
15205         return NDR_ERR_SUCCESS;
15206 }
15207
15208 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
15209 {
15210         uint32_t _ptr_print_processor_name;
15211         TALLOC_CTX *_mem_save_print_processor_name_0;
15212         if (ndr_flags & NDR_SCALARS) {
15213                 NDR_CHECK(ndr_pull_align(ndr, 5));
15214                 {
15215                         uint32_t _flags_save_string = ndr->flags;
15216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15217                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
15218                         if (_ptr_print_processor_name) {
15219                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
15220                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
15221                         } else {
15222                                 r->print_processor_name = NULL;
15223                         }
15224                         ndr->flags = _flags_save_string;
15225                 }
15226                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15227         }
15228         if (ndr_flags & NDR_BUFFERS) {
15229                 {
15230                         uint32_t _flags_save_string = ndr->flags;
15231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15232                         if (r->print_processor_name) {
15233                                 uint32_t _relative_save_offset;
15234                                 _relative_save_offset = ndr->offset;
15235                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
15236                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15237                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
15238                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
15239                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
15240                                 if (ndr->offset > ndr->relative_highest_offset) {
15241                                         ndr->relative_highest_offset = ndr->offset;
15242                                 }
15243                                 ndr->offset = _relative_save_offset;
15244                         }
15245                         ndr->flags = _flags_save_string;
15246                 }
15247         }
15248         return NDR_ERR_SUCCESS;
15249 }
15250
15251 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
15252 {
15253         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
15254         ndr->depth++;
15255         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
15256         ndr->depth++;
15257         if (r->print_processor_name) {
15258                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
15259         }
15260         ndr->depth--;
15261         ndr->depth--;
15262 }
15263
15264 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15265 {
15266         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
15267 }
15268
15269 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
15270 {
15271         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15272         {
15273                 uint32_t _flags_save_UNION = ndr->flags;
15274                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15275                 if (ndr_flags & NDR_SCALARS) {
15276                         int level = ndr_push_get_switch_value(ndr, r);
15277                         NDR_CHECK(ndr_push_union_align(ndr, 5));
15278                         switch (level) {
15279                                 case 1: {
15280                                         NDR_CHECK(ndr_push_align(ndr, 5));
15281                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15282                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15283                                 break; }
15284
15285                                 default: {
15286                                 break; }
15287
15288                         }
15289                 }
15290                 if (ndr_flags & NDR_BUFFERS) {
15291                         int level = ndr_push_get_switch_value(ndr, r);
15292                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15293                         switch (level) {
15294                                 case 1:
15295                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15296                                 break;
15297
15298                                 default:
15299                                 break;
15300
15301                         }
15302                 }
15303                 ndr->flags = _flags_save_UNION;
15304         }
15305         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15306         return NDR_ERR_SUCCESS;
15307 }
15308
15309 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
15310 {
15311         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15312         int level;
15313         {
15314                 uint32_t _flags_save_UNION = ndr->flags;
15315                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15316                 level = ndr_pull_get_switch_value(ndr, r);
15317                 if (ndr_flags & NDR_SCALARS) {
15318                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
15319                         switch (level) {
15320                                 case 1: {
15321                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15322                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15323                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15324                                 break; }
15325
15326                                 default: {
15327                                 break; }
15328
15329                         }
15330                 }
15331                 if (ndr_flags & NDR_BUFFERS) {
15332                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15333                         switch (level) {
15334                                 case 1:
15335                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15336                                 break;
15337
15338                                 default:
15339                                 break;
15340
15341                         }
15342                 }
15343                 ndr->flags = _flags_save_UNION;
15344         }
15345         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15346         return NDR_ERR_SUCCESS;
15347 }
15348
15349 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
15350 {
15351         int level;
15352         {
15353                 uint32_t _flags_save_UNION = ndr->flags;
15354                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15355                 level = ndr_print_get_switch_value(ndr, r);
15356                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
15357                 switch (level) {
15358                         case 1:
15359                                 ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
15360                         break;
15361
15362                         default:
15363                         break;
15364
15365                 }
15366                 ndr->flags = _flags_save_UNION;
15367         }
15368 }
15369
15370 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15371 {
15372         if (ndr_flags & NDR_SCALARS) {
15373                 NDR_CHECK(ndr_push_align(ndr, 4));
15374                 {
15375                         uint32_t _flags_save_string = ndr->flags;
15376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15377                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15378                         ndr->flags = _flags_save_string;
15379                 }
15380                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15381         }
15382         if (ndr_flags & NDR_BUFFERS) {
15383         }
15384         return NDR_ERR_SUCCESS;
15385 }
15386
15387 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15388 {
15389         if (ndr_flags & NDR_SCALARS) {
15390                 NDR_CHECK(ndr_pull_align(ndr, 4));
15391                 {
15392                         uint32_t _flags_save_string = ndr->flags;
15393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15394                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15395                         ndr->flags = _flags_save_string;
15396                 }
15397                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15398         }
15399         if (ndr_flags & NDR_BUFFERS) {
15400         }
15401         return NDR_ERR_SUCCESS;
15402 }
15403
15404 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15405 {
15406         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15407         ndr->depth++;
15408         ndr_print_string(ndr, "directory_name", r->directory_name);
15409         ndr->depth--;
15410 }
15411
15412 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15413 {
15414         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15415 }
15416
15417 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15418 {
15419         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15420         {
15421                 uint32_t _flags_save_UNION = ndr->flags;
15422                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15423                 if (ndr_flags & NDR_SCALARS) {
15424                         int level = ndr_push_get_switch_value(ndr, r);
15425                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15426                         switch (level) {
15427                                 case 1: {
15428                                         NDR_CHECK(ndr_push_align(ndr, 4));
15429                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15430                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15431                                 break; }
15432
15433                                 default: {
15434                                         NDR_CHECK(ndr_push_align(ndr, 4));
15435                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15436                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15437                                 break; }
15438
15439                         }
15440                 }
15441                 if (ndr_flags & NDR_BUFFERS) {
15442                         int level = ndr_push_get_switch_value(ndr, r);
15443                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15444                         switch (level) {
15445                                 case 1:
15446                                 break;
15447
15448                                 default:
15449                                 break;
15450
15451                         }
15452                 }
15453                 ndr->flags = _flags_save_UNION;
15454         }
15455         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15456         return NDR_ERR_SUCCESS;
15457 }
15458
15459 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15460 {
15461         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15462         int level;
15463         {
15464                 uint32_t _flags_save_UNION = ndr->flags;
15465                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15466                 level = ndr_pull_get_switch_value(ndr, r);
15467                 if (ndr_flags & NDR_SCALARS) {
15468                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15469                         switch (level) {
15470                                 case 1: {
15471                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15472                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15473                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15474                                 break; }
15475
15476                                 default: {
15477                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15478                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15479                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15480                                 break; }
15481
15482                         }
15483                 }
15484                 if (ndr_flags & NDR_BUFFERS) {
15485                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15486                         switch (level) {
15487                                 case 1:
15488                                 break;
15489
15490                                 default:
15491                                 break;
15492
15493                         }
15494                 }
15495                 ndr->flags = _flags_save_UNION;
15496         }
15497         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15498         return NDR_ERR_SUCCESS;
15499 }
15500
15501 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15502 {
15503         int level;
15504         {
15505                 uint32_t _flags_save_UNION = ndr->flags;
15506                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15507                 level = ndr_print_get_switch_value(ndr, r);
15508                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15509                 switch (level) {
15510                         case 1:
15511                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15512                         break;
15513
15514                         default:
15515                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15516                         break;
15517
15518                 }
15519                 ndr->flags = _flags_save_UNION;
15520         }
15521 }
15522
15523 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15524 {
15525         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15526         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15527 }
15528
15529 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15530 {
15531         if (ndr_flags & NDR_SCALARS) {
15532                 NDR_CHECK(ndr_push_align(ndr, 5));
15533                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15534                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15536                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15537         }
15538         if (ndr_flags & NDR_BUFFERS) {
15539                 if (r->document_name) {
15540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15542                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15543                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15544                 }
15545                 if (r->output_file) {
15546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15547                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15548                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15549                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15550                 }
15551                 if (r->datatype) {
15552                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15553                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15554                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15555                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15556                 }
15557         }
15558         return NDR_ERR_SUCCESS;
15559 }
15560
15561 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15562 {
15563         uint32_t _ptr_document_name;
15564         TALLOC_CTX *_mem_save_document_name_0;
15565         uint32_t _ptr_output_file;
15566         TALLOC_CTX *_mem_save_output_file_0;
15567         uint32_t _ptr_datatype;
15568         TALLOC_CTX *_mem_save_datatype_0;
15569         if (ndr_flags & NDR_SCALARS) {
15570                 NDR_CHECK(ndr_pull_align(ndr, 5));
15571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15572                 if (_ptr_document_name) {
15573                         NDR_PULL_ALLOC(ndr, r->document_name);
15574                 } else {
15575                         r->document_name = NULL;
15576                 }
15577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15578                 if (_ptr_output_file) {
15579                         NDR_PULL_ALLOC(ndr, r->output_file);
15580                 } else {
15581                         r->output_file = NULL;
15582                 }
15583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15584                 if (_ptr_datatype) {
15585                         NDR_PULL_ALLOC(ndr, r->datatype);
15586                 } else {
15587                         r->datatype = NULL;
15588                 }
15589                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15590         }
15591         if (ndr_flags & NDR_BUFFERS) {
15592                 if (r->document_name) {
15593                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15594                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15597                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15598                                 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));
15599                         }
15600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15603                 }
15604                 if (r->output_file) {
15605                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15606                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15609                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15610                                 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));
15611                         }
15612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15615                 }
15616                 if (r->datatype) {
15617                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15618                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15621                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15622                                 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));
15623                         }
15624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15627                 }
15628         }
15629         return NDR_ERR_SUCCESS;
15630 }
15631
15632 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15633 {
15634         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15635         ndr->depth++;
15636         ndr_print_ptr(ndr, "document_name", r->document_name);
15637         ndr->depth++;
15638         if (r->document_name) {
15639                 ndr_print_string(ndr, "document_name", r->document_name);
15640         }
15641         ndr->depth--;
15642         ndr_print_ptr(ndr, "output_file", r->output_file);
15643         ndr->depth++;
15644         if (r->output_file) {
15645                 ndr_print_string(ndr, "output_file", r->output_file);
15646         }
15647         ndr->depth--;
15648         ndr_print_ptr(ndr, "datatype", r->datatype);
15649         ndr->depth++;
15650         if (r->datatype) {
15651                 ndr_print_string(ndr, "datatype", r->datatype);
15652         }
15653         ndr->depth--;
15654         ndr->depth--;
15655 }
15656
15657 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15658 {
15659         if (ndr_flags & NDR_SCALARS) {
15660                 int level = ndr_push_get_switch_value(ndr, r);
15661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15662                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15663                 switch (level) {
15664                         case 1: {
15665                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15666                         break; }
15667
15668                         case 2: {
15669                         break; }
15670
15671                         case 3: {
15672                         break; }
15673
15674                         default: {
15675                         break; }
15676
15677                 }
15678         }
15679         if (ndr_flags & NDR_BUFFERS) {
15680                 int level = ndr_push_get_switch_value(ndr, r);
15681                 switch (level) {
15682                         case 1:
15683                                 if (r->info1) {
15684                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15685                                 }
15686                         break;
15687
15688                         case 2:
15689                         break;
15690
15691                         case 3:
15692                         break;
15693
15694                         default:
15695                         break;
15696
15697                 }
15698         }
15699         return NDR_ERR_SUCCESS;
15700 }
15701
15702 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15703 {
15704         int level;
15705         uint32_t _level;
15706         TALLOC_CTX *_mem_save_info1_0;
15707         level = ndr_pull_get_switch_value(ndr, r);
15708         if (ndr_flags & NDR_SCALARS) {
15709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15710                 if (_level != level) {
15711                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15712                 }
15713                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15714                 switch (level) {
15715                         case 1: {
15716                                 uint32_t _ptr_info1;
15717                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15718                                 if (_ptr_info1) {
15719                                         NDR_PULL_ALLOC(ndr, r->info1);
15720                                 } else {
15721                                         r->info1 = NULL;
15722                                 }
15723                         break; }
15724
15725                         case 2: {
15726                         break; }
15727
15728                         case 3: {
15729                         break; }
15730
15731                         default: {
15732                         break; }
15733
15734                 }
15735         }
15736         if (ndr_flags & NDR_BUFFERS) {
15737                 switch (level) {
15738                         case 1:
15739                                 if (r->info1) {
15740                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15741                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15742                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15743                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15744                                 }
15745                         break;
15746
15747                         case 2:
15748                         break;
15749
15750                         case 3:
15751                         break;
15752
15753                         default:
15754                         break;
15755
15756                 }
15757         }
15758         return NDR_ERR_SUCCESS;
15759 }
15760
15761 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15762 {
15763         int level;
15764         level = ndr_print_get_switch_value(ndr, r);
15765         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15766         switch (level) {
15767                 case 1:
15768                         ndr_print_ptr(ndr, "info1", r->info1);
15769                         ndr->depth++;
15770                         if (r->info1) {
15771                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15772                         }
15773                         ndr->depth--;
15774                 break;
15775
15776                 case 2:
15777                 break;
15778
15779                 case 3:
15780                 break;
15781
15782                 default:
15783                 break;
15784
15785         }
15786 }
15787
15788 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15789 {
15790         if (ndr_flags & NDR_SCALARS) {
15791                 NDR_CHECK(ndr_push_align(ndr, 4));
15792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15797                 {
15798                         uint32_t _flags_save_string = ndr->flags;
15799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15800                         {
15801                                 struct ndr_push *_ndr_extra_string;
15802                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15803                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15804                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15805                         }
15806                         ndr->flags = _flags_save_string;
15807                 }
15808                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15809         }
15810         if (ndr_flags & NDR_BUFFERS) {
15811         }
15812         return NDR_ERR_SUCCESS;
15813 }
15814
15815 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15816 {
15817         if (ndr_flags & NDR_SCALARS) {
15818                 NDR_CHECK(ndr_pull_align(ndr, 4));
15819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15824                 {
15825                         uint32_t _flags_save_string = ndr->flags;
15826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15827                         {
15828                                 struct ndr_pull *_ndr_extra_string;
15829                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15830                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15831                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15832                         }
15833                         ndr->flags = _flags_save_string;
15834                 }
15835                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15836         }
15837         if (ndr_flags & NDR_BUFFERS) {
15838         }
15839         return NDR_ERR_SUCCESS;
15840 }
15841
15842 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15843 {
15844         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15845         ndr->depth++;
15846         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);
15847         ndr_print_uint32(ndr, "major", r->major);
15848         ndr_print_uint32(ndr, "minor", r->minor);
15849         ndr_print_uint32(ndr, "build", r->build);
15850         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15851         ndr_print_string(ndr, "extra_string", r->extra_string);
15852         ndr->depth--;
15853 }
15854
15855 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15856 {
15857         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15858 }
15859
15860 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15861 {
15862         if (ndr_flags & NDR_SCALARS) {
15863                 NDR_CHECK(ndr_push_align(ndr, 4));
15864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15869                 {
15870                         uint32_t _flags_save_string = ndr->flags;
15871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15872                         {
15873                                 struct ndr_push *_ndr_extra_string;
15874                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15875                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15876                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15877                         }
15878                         ndr->flags = _flags_save_string;
15879                 }
15880                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15881                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15882                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15883                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15884                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15885                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15886         }
15887         if (ndr_flags & NDR_BUFFERS) {
15888         }
15889         return NDR_ERR_SUCCESS;
15890 }
15891
15892 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15893 {
15894         if (ndr_flags & NDR_SCALARS) {
15895                 NDR_CHECK(ndr_pull_align(ndr, 4));
15896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15901                 {
15902                         uint32_t _flags_save_string = ndr->flags;
15903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15904                         {
15905                                 struct ndr_pull *_ndr_extra_string;
15906                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15907                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15908                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15909                         }
15910                         ndr->flags = _flags_save_string;
15911                 }
15912                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15913                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15914                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15915                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15916                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15917                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15918         }
15919         if (ndr_flags & NDR_BUFFERS) {
15920         }
15921         return NDR_ERR_SUCCESS;
15922 }
15923
15924 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15925 {
15926         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15927         ndr->depth++;
15928         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);
15929         ndr_print_uint32(ndr, "major", r->major);
15930         ndr_print_uint32(ndr, "minor", r->minor);
15931         ndr_print_uint32(ndr, "build", r->build);
15932         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15933         ndr_print_string(ndr, "extra_string", r->extra_string);
15934         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15935         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15936         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15937         ndr_print_uint8(ndr, "product_type", r->product_type);
15938         ndr_print_uint8(ndr, "reserved", r->reserved);
15939         ndr->depth--;
15940 }
15941
15942 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15943 {
15944         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15945 }
15946
15947 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15948 {
15949         if (ndr_flags & NDR_SCALARS) {
15950                 int level = ndr_push_get_switch_value(ndr, r);
15951                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15952                 switch (level) {
15953                         case REG_NONE: {
15954                         break; }
15955
15956                         case REG_SZ: {
15957                                 {
15958                                         uint32_t _flags_save_string = ndr->flags;
15959                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15960                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15961                                         ndr->flags = _flags_save_string;
15962                                 }
15963                         break; }
15964
15965                         case REG_BINARY: {
15966                                 {
15967                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15968                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15969                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15970                                         ndr->flags = _flags_save_DATA_BLOB;
15971                                 }
15972                         break; }
15973
15974                         case REG_DWORD: {
15975                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15976                         break; }
15977
15978                         case REG_MULTI_SZ: {
15979                                 {
15980                                         uint32_t _flags_save_string_array = ndr->flags;
15981                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15982                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15983                                         ndr->flags = _flags_save_string_array;
15984                                 }
15985                         break; }
15986
15987                         default: {
15988                                 {
15989                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15990                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15991                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15992                                         ndr->flags = _flags_save_DATA_BLOB;
15993                                 }
15994                         break; }
15995
15996                 }
15997         }
15998         if (ndr_flags & NDR_BUFFERS) {
15999                 int level = ndr_push_get_switch_value(ndr, r);
16000                 switch (level) {
16001                         case REG_NONE:
16002                         break;
16003
16004                         case REG_SZ:
16005                         break;
16006
16007                         case REG_BINARY:
16008                         break;
16009
16010                         case REG_DWORD:
16011                         break;
16012
16013                         case REG_MULTI_SZ:
16014                         break;
16015
16016                         default:
16017                         break;
16018
16019                 }
16020         }
16021         return NDR_ERR_SUCCESS;
16022 }
16023
16024 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
16025 {
16026         int level;
16027         level = ndr_pull_get_switch_value(ndr, r);
16028         if (ndr_flags & NDR_SCALARS) {
16029                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
16030                 switch (level) {
16031                         case REG_NONE: {
16032                         break; }
16033
16034                         case REG_SZ: {
16035                                 {
16036                                         uint32_t _flags_save_string = ndr->flags;
16037                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16038                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
16039                                         ndr->flags = _flags_save_string;
16040                                 }
16041                         break; }
16042
16043                         case REG_BINARY: {
16044                                 {
16045                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16046                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16047                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
16048                                         ndr->flags = _flags_save_DATA_BLOB;
16049                                 }
16050                         break; }
16051
16052                         case REG_DWORD: {
16053                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
16054                         break; }
16055
16056                         case REG_MULTI_SZ: {
16057                                 {
16058                                         uint32_t _flags_save_string_array = ndr->flags;
16059                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16060                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
16061                                         ndr->flags = _flags_save_string_array;
16062                                 }
16063                         break; }
16064
16065                         default: {
16066                                 {
16067                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16068                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16069                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
16070                                         ndr->flags = _flags_save_DATA_BLOB;
16071                                 }
16072                         break; }
16073
16074                 }
16075         }
16076         if (ndr_flags & NDR_BUFFERS) {
16077                 switch (level) {
16078                         case REG_NONE:
16079                         break;
16080
16081                         case REG_SZ:
16082                         break;
16083
16084                         case REG_BINARY:
16085                         break;
16086
16087                         case REG_DWORD:
16088                         break;
16089
16090                         case REG_MULTI_SZ:
16091                         break;
16092
16093                         default:
16094                         break;
16095
16096                 }
16097         }
16098         return NDR_ERR_SUCCESS;
16099 }
16100
16101 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
16102 {
16103         int level;
16104         level = ndr_print_get_switch_value(ndr, r);
16105         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
16106         switch (level) {
16107                 case REG_NONE:
16108                 break;
16109
16110                 case REG_SZ:
16111                         ndr_print_string(ndr, "string", r->string);
16112                 break;
16113
16114                 case REG_BINARY:
16115                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
16116                 break;
16117
16118                 case REG_DWORD:
16119                         ndr_print_uint32(ndr, "value", r->value);
16120                 break;
16121
16122                 case REG_MULTI_SZ:
16123                         ndr_print_string_array(ndr, "string_array", r->string_array);
16124                 break;
16125
16126                 default:
16127                         ndr_print_DATA_BLOB(ndr, "data", r->data);
16128                 break;
16129
16130         }
16131 }
16132
16133 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
16134 {
16135         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16136         return NDR_ERR_SUCCESS;
16137 }
16138
16139 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
16140 {
16141         uint32_t v;
16142         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16143         *r = v;
16144         return NDR_ERR_SUCCESS;
16145 }
16146
16147 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
16148 {
16149         const char *val = NULL;
16150
16151         switch (r) {
16152                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
16153                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
16154                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
16155         }
16156         ndr_print_enum(ndr, name, "ENUM", val, r);
16157 }
16158
16159 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
16160 {
16161         if (ndr_flags & NDR_SCALARS) {
16162                 NDR_CHECK(ndr_push_align(ndr, 4));
16163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
16164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
16165                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16166         }
16167         if (ndr_flags & NDR_BUFFERS) {
16168         }
16169         return NDR_ERR_SUCCESS;
16170 }
16171
16172 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
16173 {
16174         if (ndr_flags & NDR_SCALARS) {
16175                 NDR_CHECK(ndr_pull_align(ndr, 4));
16176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
16177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
16178                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16179         }
16180         if (ndr_flags & NDR_BUFFERS) {
16181         }
16182         return NDR_ERR_SUCCESS;
16183 }
16184
16185 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
16186 {
16187         ndr_print_struct(ndr, name, "spoolss_FormSize");
16188         ndr->depth++;
16189         ndr_print_uint32(ndr, "width", r->width);
16190         ndr_print_uint32(ndr, "height", r->height);
16191         ndr->depth--;
16192 }
16193
16194 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
16195 {
16196         if (ndr_flags & NDR_SCALARS) {
16197                 NDR_CHECK(ndr_push_align(ndr, 4));
16198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
16199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
16200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
16201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
16202                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16203         }
16204         if (ndr_flags & NDR_BUFFERS) {
16205         }
16206         return NDR_ERR_SUCCESS;
16207 }
16208
16209 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
16210 {
16211         if (ndr_flags & NDR_SCALARS) {
16212                 NDR_CHECK(ndr_pull_align(ndr, 4));
16213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
16214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
16215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
16216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
16217                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16218         }
16219         if (ndr_flags & NDR_BUFFERS) {
16220         }
16221         return NDR_ERR_SUCCESS;
16222 }
16223
16224 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
16225 {
16226         ndr_print_struct(ndr, name, "spoolss_FormArea");
16227         ndr->depth++;
16228         ndr_print_uint32(ndr, "left", r->left);
16229         ndr_print_uint32(ndr, "top", r->top);
16230         ndr_print_uint32(ndr, "right", r->right);
16231         ndr_print_uint32(ndr, "bottom", r->bottom);
16232         ndr->depth--;
16233 }
16234
16235 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
16236 {
16237         if (ndr_flags & NDR_SCALARS) {
16238                 NDR_CHECK(ndr_push_align(ndr, 5));
16239                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16240                 {
16241                         uint32_t _flags_save_string = ndr->flags;
16242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16243                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16244                         ndr->flags = _flags_save_string;
16245                 }
16246                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16247                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16248                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16249         }
16250         if (ndr_flags & NDR_BUFFERS) {
16251                 {
16252                         uint32_t _flags_save_string = ndr->flags;
16253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16254                         if (r->form_name) {
16255                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16256                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16257                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16258                         }
16259                         ndr->flags = _flags_save_string;
16260                 }
16261         }
16262         return NDR_ERR_SUCCESS;
16263 }
16264
16265 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
16266 {
16267         uint32_t _ptr_form_name;
16268         TALLOC_CTX *_mem_save_form_name_0;
16269         if (ndr_flags & NDR_SCALARS) {
16270                 NDR_CHECK(ndr_pull_align(ndr, 5));
16271                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16272                 {
16273                         uint32_t _flags_save_string = ndr->flags;
16274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16275                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16276                         if (_ptr_form_name) {
16277                                 NDR_PULL_ALLOC(ndr, r->form_name);
16278                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16279                         } else {
16280                                 r->form_name = NULL;
16281                         }
16282                         ndr->flags = _flags_save_string;
16283                 }
16284                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16285                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16286                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16287         }
16288         if (ndr_flags & NDR_BUFFERS) {
16289                 {
16290                         uint32_t _flags_save_string = ndr->flags;
16291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16292                         if (r->form_name) {
16293                                 uint32_t _relative_save_offset;
16294                                 _relative_save_offset = ndr->offset;
16295                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16296                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16297                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16298                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16299                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16300                                 if (ndr->offset > ndr->relative_highest_offset) {
16301                                         ndr->relative_highest_offset = ndr->offset;
16302                                 }
16303                                 ndr->offset = _relative_save_offset;
16304                         }
16305                         ndr->flags = _flags_save_string;
16306                 }
16307         }
16308         return NDR_ERR_SUCCESS;
16309 }
16310
16311 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
16312 {
16313         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
16314         ndr->depth++;
16315         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16316         ndr_print_ptr(ndr, "form_name", r->form_name);
16317         ndr->depth++;
16318         if (r->form_name) {
16319                 ndr_print_string(ndr, "form_name", r->form_name);
16320         }
16321         ndr->depth--;
16322         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16323         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16324         ndr->depth--;
16325 }
16326
16327 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16328 {
16329         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
16330 }
16331
16332 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16333 {
16334         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16335         return NDR_ERR_SUCCESS;
16336 }
16337
16338 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16339 {
16340         uint32_t v;
16341         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16342         *r = v;
16343         return NDR_ERR_SUCCESS;
16344 }
16345
16346 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
16347 {
16348         ndr_print_uint32(ndr, name, r);
16349         ndr->depth++;
16350         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
16351         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
16352         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
16353         ndr->depth--;
16354 }
16355
16356 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
16357 {
16358         if (ndr_flags & NDR_SCALARS) {
16359                 NDR_CHECK(ndr_push_align(ndr, 5));
16360                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16361                 {
16362                         uint32_t _flags_save_string = ndr->flags;
16363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16364                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16365                         ndr->flags = _flags_save_string;
16366                 }
16367                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16368                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16369                 {
16370                         uint32_t _flags_save_string = ndr->flags;
16371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16372                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
16373                         ndr->flags = _flags_save_string;
16374                 }
16375                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16376                 {
16377                         uint32_t _flags_save_string = ndr->flags;
16378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16379                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
16380                         ndr->flags = _flags_save_string;
16381                 }
16382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16383                 {
16384                         uint32_t _flags_save_string = ndr->flags;
16385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16386                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16387                         ndr->flags = _flags_save_string;
16388                 }
16389                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16390                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16391                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16392         }
16393         if (ndr_flags & NDR_BUFFERS) {
16394                 {
16395                         uint32_t _flags_save_string = ndr->flags;
16396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16397                         if (r->form_name) {
16398                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16399                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16400                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16401                         }
16402                         ndr->flags = _flags_save_string;
16403                 }
16404                 {
16405                         uint32_t _flags_save_string = ndr->flags;
16406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16407                         if (r->keyword) {
16408                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->keyword));
16409                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16410                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->keyword));
16411                         }
16412                         ndr->flags = _flags_save_string;
16413                 }
16414                 {
16415                         uint32_t _flags_save_string = ndr->flags;
16416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16417                         if (r->mui_dll) {
16418                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->mui_dll));
16419                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16420                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->mui_dll));
16421                         }
16422                         ndr->flags = _flags_save_string;
16423                 }
16424                 {
16425                         uint32_t _flags_save_string = ndr->flags;
16426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16427                         if (r->display_name) {
16428                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
16429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16430                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
16431                         }
16432                         ndr->flags = _flags_save_string;
16433                 }
16434         }
16435         return NDR_ERR_SUCCESS;
16436 }
16437
16438 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16439 {
16440         uint32_t _ptr_form_name;
16441         TALLOC_CTX *_mem_save_form_name_0;
16442         uint32_t _ptr_keyword;
16443         TALLOC_CTX *_mem_save_keyword_0;
16444         uint32_t _ptr_mui_dll;
16445         TALLOC_CTX *_mem_save_mui_dll_0;
16446         uint32_t _ptr_display_name;
16447         TALLOC_CTX *_mem_save_display_name_0;
16448         if (ndr_flags & NDR_SCALARS) {
16449                 NDR_CHECK(ndr_pull_align(ndr, 5));
16450                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16451                 {
16452                         uint32_t _flags_save_string = ndr->flags;
16453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16454                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16455                         if (_ptr_form_name) {
16456                                 NDR_PULL_ALLOC(ndr, r->form_name);
16457                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16458                         } else {
16459                                 r->form_name = NULL;
16460                         }
16461                         ndr->flags = _flags_save_string;
16462                 }
16463                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16464                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16465                 {
16466                         uint32_t _flags_save_string = ndr->flags;
16467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16468                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16469                         if (_ptr_keyword) {
16470                                 NDR_PULL_ALLOC(ndr, r->keyword);
16471                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16472                         } else {
16473                                 r->keyword = NULL;
16474                         }
16475                         ndr->flags = _flags_save_string;
16476                 }
16477                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16478                 {
16479                         uint32_t _flags_save_string = ndr->flags;
16480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16481                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16482                         if (_ptr_mui_dll) {
16483                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16484                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16485                         } else {
16486                                 r->mui_dll = NULL;
16487                         }
16488                         ndr->flags = _flags_save_string;
16489                 }
16490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16491                 {
16492                         uint32_t _flags_save_string = ndr->flags;
16493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16494                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16495                         if (_ptr_display_name) {
16496                                 NDR_PULL_ALLOC(ndr, r->display_name);
16497                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16498                         } else {
16499                                 r->display_name = NULL;
16500                         }
16501                         ndr->flags = _flags_save_string;
16502                 }
16503                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16504                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16505                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16506         }
16507         if (ndr_flags & NDR_BUFFERS) {
16508                 {
16509                         uint32_t _flags_save_string = ndr->flags;
16510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16511                         if (r->form_name) {
16512                                 uint32_t _relative_save_offset;
16513                                 _relative_save_offset = ndr->offset;
16514                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16515                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16516                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16517                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16518                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16519                                 if (ndr->offset > ndr->relative_highest_offset) {
16520                                         ndr->relative_highest_offset = ndr->offset;
16521                                 }
16522                                 ndr->offset = _relative_save_offset;
16523                         }
16524                         ndr->flags = _flags_save_string;
16525                 }
16526                 {
16527                         uint32_t _flags_save_string = ndr->flags;
16528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16529                         if (r->keyword) {
16530                                 uint32_t _relative_save_offset;
16531                                 _relative_save_offset = ndr->offset;
16532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16533                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16534                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16537                                 if (ndr->offset > ndr->relative_highest_offset) {
16538                                         ndr->relative_highest_offset = ndr->offset;
16539                                 }
16540                                 ndr->offset = _relative_save_offset;
16541                         }
16542                         ndr->flags = _flags_save_string;
16543                 }
16544                 {
16545                         uint32_t _flags_save_string = ndr->flags;
16546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16547                         if (r->mui_dll) {
16548                                 uint32_t _relative_save_offset;
16549                                 _relative_save_offset = ndr->offset;
16550                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16551                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16552                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16553                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16554                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16555                                 if (ndr->offset > ndr->relative_highest_offset) {
16556                                         ndr->relative_highest_offset = ndr->offset;
16557                                 }
16558                                 ndr->offset = _relative_save_offset;
16559                         }
16560                         ndr->flags = _flags_save_string;
16561                 }
16562                 {
16563                         uint32_t _flags_save_string = ndr->flags;
16564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16565                         if (r->display_name) {
16566                                 uint32_t _relative_save_offset;
16567                                 _relative_save_offset = ndr->offset;
16568                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16569                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16570                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16571                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16572                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16573                                 if (ndr->offset > ndr->relative_highest_offset) {
16574                                         ndr->relative_highest_offset = ndr->offset;
16575                                 }
16576                                 ndr->offset = _relative_save_offset;
16577                         }
16578                         ndr->flags = _flags_save_string;
16579                 }
16580         }
16581         return NDR_ERR_SUCCESS;
16582 }
16583
16584 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16585 {
16586         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16587         ndr->depth++;
16588         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16589         ndr_print_ptr(ndr, "form_name", r->form_name);
16590         ndr->depth++;
16591         if (r->form_name) {
16592                 ndr_print_string(ndr, "form_name", r->form_name);
16593         }
16594         ndr->depth--;
16595         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16596         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16597         ndr_print_ptr(ndr, "keyword", r->keyword);
16598         ndr->depth++;
16599         if (r->keyword) {
16600                 ndr_print_string(ndr, "keyword", r->keyword);
16601         }
16602         ndr->depth--;
16603         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16604         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16605         ndr->depth++;
16606         if (r->mui_dll) {
16607                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16608         }
16609         ndr->depth--;
16610         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16611         ndr_print_ptr(ndr, "display_name", r->display_name);
16612         ndr->depth++;
16613         if (r->display_name) {
16614                 ndr_print_string(ndr, "display_name", r->display_name);
16615         }
16616         ndr->depth--;
16617         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16618         ndr_print_uint16(ndr, "unused", r->unused);
16619         ndr->depth--;
16620 }
16621
16622 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16623 {
16624         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16625 }
16626
16627 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16628 {
16629         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16630         {
16631                 uint32_t _flags_save_UNION = ndr->flags;
16632                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16633                 if (ndr_flags & NDR_SCALARS) {
16634                         int level = ndr_push_get_switch_value(ndr, r);
16635                         NDR_CHECK(ndr_push_union_align(ndr, 5));
16636                         switch (level) {
16637                                 case 1: {
16638                                         NDR_CHECK(ndr_push_align(ndr, 5));
16639                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16640                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16641                                 break; }
16642
16643                                 case 2: {
16644                                         NDR_CHECK(ndr_push_align(ndr, 5));
16645                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16646                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16647                                 break; }
16648
16649                                 default: {
16650                                 break; }
16651
16652                         }
16653                 }
16654                 if (ndr_flags & NDR_BUFFERS) {
16655                         int level = ndr_push_get_switch_value(ndr, r);
16656                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16657                         switch (level) {
16658                                 case 1:
16659                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16660                                 break;
16661
16662                                 case 2:
16663                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16664                                 break;
16665
16666                                 default:
16667                                 break;
16668
16669                         }
16670                 }
16671                 ndr->flags = _flags_save_UNION;
16672         }
16673         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16674         return NDR_ERR_SUCCESS;
16675 }
16676
16677 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16678 {
16679         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16680         int level;
16681         {
16682                 uint32_t _flags_save_UNION = ndr->flags;
16683                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16684                 level = ndr_pull_get_switch_value(ndr, r);
16685                 if (ndr_flags & NDR_SCALARS) {
16686                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
16687                         switch (level) {
16688                                 case 1: {
16689                                         NDR_CHECK(ndr_pull_align(ndr, 5));
16690                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16691                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16692                                 break; }
16693
16694                                 case 2: {
16695                                         NDR_CHECK(ndr_pull_align(ndr, 5));
16696                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16697                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16698                                 break; }
16699
16700                                 default: {
16701                                 break; }
16702
16703                         }
16704                 }
16705                 if (ndr_flags & NDR_BUFFERS) {
16706                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16707                         switch (level) {
16708                                 case 1:
16709                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16710                                 break;
16711
16712                                 case 2:
16713                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16714                                 break;
16715
16716                                 default:
16717                                 break;
16718
16719                         }
16720                 }
16721                 ndr->flags = _flags_save_UNION;
16722         }
16723         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16724         return NDR_ERR_SUCCESS;
16725 }
16726
16727 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16728 {
16729         int level;
16730         {
16731                 uint32_t _flags_save_UNION = ndr->flags;
16732                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16733                 level = ndr_print_get_switch_value(ndr, r);
16734                 ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16735                 switch (level) {
16736                         case 1:
16737                                 ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16738                         break;
16739
16740                         case 2:
16741                                 ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16742                         break;
16743
16744                         default:
16745                         break;
16746
16747                 }
16748                 ndr->flags = _flags_save_UNION;
16749         }
16750 }
16751
16752 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16753 {
16754         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
16755         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16756 }
16757
16758 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16759 {
16760         if (ndr_flags & NDR_SCALARS) {
16761                 NDR_CHECK(ndr_push_align(ndr, 5));
16762                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16764                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16765                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16766                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16767         }
16768         if (ndr_flags & NDR_BUFFERS) {
16769                 if (r->form_name) {
16770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16774                 }
16775         }
16776         return NDR_ERR_SUCCESS;
16777 }
16778
16779 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16780 {
16781         uint32_t _ptr_form_name;
16782         TALLOC_CTX *_mem_save_form_name_0;
16783         if (ndr_flags & NDR_SCALARS) {
16784                 NDR_CHECK(ndr_pull_align(ndr, 5));
16785                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16787                 if (_ptr_form_name) {
16788                         NDR_PULL_ALLOC(ndr, r->form_name);
16789                 } else {
16790                         r->form_name = NULL;
16791                 }
16792                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16793                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16794                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16795         }
16796         if (ndr_flags & NDR_BUFFERS) {
16797                 if (r->form_name) {
16798                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16799                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16802                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16803                                 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));
16804                         }
16805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16806                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16808                 }
16809         }
16810         return NDR_ERR_SUCCESS;
16811 }
16812
16813 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16814 {
16815         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16816         ndr->depth++;
16817         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16818         ndr_print_ptr(ndr, "form_name", r->form_name);
16819         ndr->depth++;
16820         if (r->form_name) {
16821                 ndr_print_string(ndr, "form_name", r->form_name);
16822         }
16823         ndr->depth--;
16824         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16825         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16826         ndr->depth--;
16827 }
16828
16829 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16830 {
16831         if (ndr_flags & NDR_SCALARS) {
16832                 NDR_CHECK(ndr_push_align(ndr, 5));
16833                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16835                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16836                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16838                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16839                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16843                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16844         }
16845         if (ndr_flags & NDR_BUFFERS) {
16846                 if (r->form_name) {
16847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16849                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16850                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16851                 }
16852                 if (r->keyword) {
16853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16855                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16856                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16857                 }
16858                 if (r->mui_dll) {
16859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16862                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16863                 }
16864                 if (r->display_name) {
16865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16867                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16868                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16869                 }
16870         }
16871         return NDR_ERR_SUCCESS;
16872 }
16873
16874 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16875 {
16876         uint32_t _ptr_form_name;
16877         TALLOC_CTX *_mem_save_form_name_0;
16878         uint32_t _ptr_keyword;
16879         TALLOC_CTX *_mem_save_keyword_0;
16880         uint32_t _ptr_mui_dll;
16881         TALLOC_CTX *_mem_save_mui_dll_0;
16882         uint32_t _ptr_display_name;
16883         TALLOC_CTX *_mem_save_display_name_0;
16884         if (ndr_flags & NDR_SCALARS) {
16885                 NDR_CHECK(ndr_pull_align(ndr, 5));
16886                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16887                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16888                 if (_ptr_form_name) {
16889                         NDR_PULL_ALLOC(ndr, r->form_name);
16890                 } else {
16891                         r->form_name = NULL;
16892                 }
16893                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16894                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16896                 if (_ptr_keyword) {
16897                         NDR_PULL_ALLOC(ndr, r->keyword);
16898                 } else {
16899                         r->keyword = NULL;
16900                 }
16901                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16903                 if (_ptr_mui_dll) {
16904                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16905                 } else {
16906                         r->mui_dll = NULL;
16907                 }
16908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16909                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16910                 if (_ptr_display_name) {
16911                         NDR_PULL_ALLOC(ndr, r->display_name);
16912                 } else {
16913                         r->display_name = NULL;
16914                 }
16915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16916                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16917         }
16918         if (ndr_flags & NDR_BUFFERS) {
16919                 if (r->form_name) {
16920                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16921                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16922                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16923                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16924                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16925                                 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));
16926                         }
16927                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16930                 }
16931                 if (r->keyword) {
16932                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16933                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16934                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16935                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16936                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16937                                 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));
16938                         }
16939                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16942                 }
16943                 if (r->mui_dll) {
16944                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16945                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16948                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16949                                 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));
16950                         }
16951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16954                 }
16955                 if (r->display_name) {
16956                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16957                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16960                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16961                                 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));
16962                         }
16963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16966                 }
16967         }
16968         return NDR_ERR_SUCCESS;
16969 }
16970
16971 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16972 {
16973         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16974         ndr->depth++;
16975         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16976         ndr_print_ptr(ndr, "form_name", r->form_name);
16977         ndr->depth++;
16978         if (r->form_name) {
16979                 ndr_print_string(ndr, "form_name", r->form_name);
16980         }
16981         ndr->depth--;
16982         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16983         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16984         ndr_print_ptr(ndr, "keyword", r->keyword);
16985         ndr->depth++;
16986         if (r->keyword) {
16987                 ndr_print_string(ndr, "keyword", r->keyword);
16988         }
16989         ndr->depth--;
16990         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16991         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16992         ndr->depth++;
16993         if (r->mui_dll) {
16994                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16995         }
16996         ndr->depth--;
16997         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16998         ndr_print_ptr(ndr, "display_name", r->display_name);
16999         ndr->depth++;
17000         if (r->display_name) {
17001                 ndr_print_string(ndr, "display_name", r->display_name);
17002         }
17003         ndr->depth--;
17004         ndr_print_uint32(ndr, "lang_id", r->lang_id);
17005         ndr->depth--;
17006 }
17007
17008 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
17009 {
17010         if (ndr_flags & NDR_SCALARS) {
17011                 int level = ndr_push_get_switch_value(ndr, r);
17012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17013                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17014                 switch (level) {
17015                         case 1: {
17016                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
17017                         break; }
17018
17019                         case 2: {
17020                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
17021                         break; }
17022
17023                         default:
17024                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17025                 }
17026         }
17027         if (ndr_flags & NDR_BUFFERS) {
17028                 int level = ndr_push_get_switch_value(ndr, r);
17029                 switch (level) {
17030                         case 1:
17031                                 if (r->info1) {
17032                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17033                                 }
17034                         break;
17035
17036                         case 2:
17037                                 if (r->info2) {
17038                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17039                                 }
17040                         break;
17041
17042                         default:
17043                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17044                 }
17045         }
17046         return NDR_ERR_SUCCESS;
17047 }
17048
17049 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
17050 {
17051         int level;
17052         uint32_t _level;
17053         TALLOC_CTX *_mem_save_info1_0;
17054         TALLOC_CTX *_mem_save_info2_0;
17055         level = ndr_pull_get_switch_value(ndr, r);
17056         if (ndr_flags & NDR_SCALARS) {
17057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17058                 if (_level != level) {
17059                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
17060                 }
17061                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17062                 switch (level) {
17063                         case 1: {
17064                                 uint32_t _ptr_info1;
17065                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
17066                                 if (_ptr_info1) {
17067                                         NDR_PULL_ALLOC(ndr, r->info1);
17068                                 } else {
17069                                         r->info1 = NULL;
17070                                 }
17071                         break; }
17072
17073                         case 2: {
17074                                 uint32_t _ptr_info2;
17075                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
17076                                 if (_ptr_info2) {
17077                                         NDR_PULL_ALLOC(ndr, r->info2);
17078                                 } else {
17079                                         r->info2 = NULL;
17080                                 }
17081                         break; }
17082
17083                         default:
17084                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17085                 }
17086         }
17087         if (ndr_flags & NDR_BUFFERS) {
17088                 switch (level) {
17089                         case 1:
17090                                 if (r->info1) {
17091                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
17092                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
17093                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17094                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
17095                                 }
17096                         break;
17097
17098                         case 2:
17099                                 if (r->info2) {
17100                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
17101                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
17102                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17103                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
17104                                 }
17105                         break;
17106
17107                         default:
17108                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17109                 }
17110         }
17111         return NDR_ERR_SUCCESS;
17112 }
17113
17114 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
17115 {
17116         int level;
17117         level = ndr_print_get_switch_value(ndr, r);
17118         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
17119         switch (level) {
17120                 case 1:
17121                         ndr_print_ptr(ndr, "info1", r->info1);
17122                         ndr->depth++;
17123                         if (r->info1) {
17124                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
17125                         }
17126                         ndr->depth--;
17127                 break;
17128
17129                 case 2:
17130                         ndr_print_ptr(ndr, "info2", r->info2);
17131                         ndr->depth++;
17132                         if (r->info2) {
17133                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
17134                         }
17135                         ndr->depth--;
17136                 break;
17137
17138                 default:
17139                         ndr_print_bad_level(ndr, name, level);
17140         }
17141 }
17142
17143 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
17144 {
17145         if (ndr_flags & NDR_SCALARS) {
17146                 NDR_CHECK(ndr_push_align(ndr, 5));
17147                 {
17148                         uint32_t _flags_save_string = ndr->flags;
17149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17150                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17151                         ndr->flags = _flags_save_string;
17152                 }
17153                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17154         }
17155         if (ndr_flags & NDR_BUFFERS) {
17156                 {
17157                         uint32_t _flags_save_string = ndr->flags;
17158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17159                         if (r->port_name) {
17160                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17161                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17162                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17163                         }
17164                         ndr->flags = _flags_save_string;
17165                 }
17166         }
17167         return NDR_ERR_SUCCESS;
17168 }
17169
17170 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
17171 {
17172         uint32_t _ptr_port_name;
17173         TALLOC_CTX *_mem_save_port_name_0;
17174         if (ndr_flags & NDR_SCALARS) {
17175                 NDR_CHECK(ndr_pull_align(ndr, 5));
17176                 {
17177                         uint32_t _flags_save_string = ndr->flags;
17178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17179                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17180                         if (_ptr_port_name) {
17181                                 NDR_PULL_ALLOC(ndr, r->port_name);
17182                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17183                         } else {
17184                                 r->port_name = NULL;
17185                         }
17186                         ndr->flags = _flags_save_string;
17187                 }
17188                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17189         }
17190         if (ndr_flags & NDR_BUFFERS) {
17191                 {
17192                         uint32_t _flags_save_string = ndr->flags;
17193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17194                         if (r->port_name) {
17195                                 uint32_t _relative_save_offset;
17196                                 _relative_save_offset = ndr->offset;
17197                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17198                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17199                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17200                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17201                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17202                                 if (ndr->offset > ndr->relative_highest_offset) {
17203                                         ndr->relative_highest_offset = ndr->offset;
17204                                 }
17205                                 ndr->offset = _relative_save_offset;
17206                         }
17207                         ndr->flags = _flags_save_string;
17208                 }
17209         }
17210         return NDR_ERR_SUCCESS;
17211 }
17212
17213 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
17214 {
17215         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
17216         ndr->depth++;
17217         ndr_print_ptr(ndr, "port_name", r->port_name);
17218         ndr->depth++;
17219         if (r->port_name) {
17220                 ndr_print_string(ndr, "port_name", r->port_name);
17221         }
17222         ndr->depth--;
17223         ndr->depth--;
17224 }
17225
17226 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17227 {
17228         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
17229 }
17230
17231 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17232 {
17233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17234         return NDR_ERR_SUCCESS;
17235 }
17236
17237 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17238 {
17239         uint32_t v;
17240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17241         *r = v;
17242         return NDR_ERR_SUCCESS;
17243 }
17244
17245 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
17246 {
17247         ndr_print_uint32(ndr, name, r);
17248         ndr->depth++;
17249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
17250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
17251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
17252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
17253         ndr->depth--;
17254 }
17255
17256 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
17257 {
17258         if (ndr_flags & NDR_SCALARS) {
17259                 NDR_CHECK(ndr_push_align(ndr, 5));
17260                 {
17261                         uint32_t _flags_save_string = ndr->flags;
17262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17263                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17264                         ndr->flags = _flags_save_string;
17265                 }
17266                 {
17267                         uint32_t _flags_save_string = ndr->flags;
17268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17269                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17270                         ndr->flags = _flags_save_string;
17271                 }
17272                 {
17273                         uint32_t _flags_save_string = ndr->flags;
17274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17275                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
17276                         ndr->flags = _flags_save_string;
17277                 }
17278                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
17279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
17280                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17281         }
17282         if (ndr_flags & NDR_BUFFERS) {
17283                 {
17284                         uint32_t _flags_save_string = ndr->flags;
17285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17286                         if (r->port_name) {
17287                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17288                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17289                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17290                         }
17291                         ndr->flags = _flags_save_string;
17292                 }
17293                 {
17294                         uint32_t _flags_save_string = ndr->flags;
17295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17296                         if (r->monitor_name) {
17297                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17298                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17299                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17300                         }
17301                         ndr->flags = _flags_save_string;
17302                 }
17303                 {
17304                         uint32_t _flags_save_string = ndr->flags;
17305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17306                         if (r->description) {
17307                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
17308                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
17309                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
17310                         }
17311                         ndr->flags = _flags_save_string;
17312                 }
17313         }
17314         return NDR_ERR_SUCCESS;
17315 }
17316
17317 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
17318 {
17319         uint32_t _ptr_port_name;
17320         TALLOC_CTX *_mem_save_port_name_0;
17321         uint32_t _ptr_monitor_name;
17322         TALLOC_CTX *_mem_save_monitor_name_0;
17323         uint32_t _ptr_description;
17324         TALLOC_CTX *_mem_save_description_0;
17325         if (ndr_flags & NDR_SCALARS) {
17326                 NDR_CHECK(ndr_pull_align(ndr, 5));
17327                 {
17328                         uint32_t _flags_save_string = ndr->flags;
17329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17330                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17331                         if (_ptr_port_name) {
17332                                 NDR_PULL_ALLOC(ndr, r->port_name);
17333                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17334                         } else {
17335                                 r->port_name = NULL;
17336                         }
17337                         ndr->flags = _flags_save_string;
17338                 }
17339                 {
17340                         uint32_t _flags_save_string = ndr->flags;
17341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17343                         if (_ptr_monitor_name) {
17344                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17346                         } else {
17347                                 r->monitor_name = NULL;
17348                         }
17349                         ndr->flags = _flags_save_string;
17350                 }
17351                 {
17352                         uint32_t _flags_save_string = ndr->flags;
17353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
17355                         if (_ptr_description) {
17356                                 NDR_PULL_ALLOC(ndr, r->description);
17357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
17358                         } else {
17359                                 r->description = NULL;
17360                         }
17361                         ndr->flags = _flags_save_string;
17362                 }
17363                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
17364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
17365                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17366         }
17367         if (ndr_flags & NDR_BUFFERS) {
17368                 {
17369                         uint32_t _flags_save_string = ndr->flags;
17370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17371                         if (r->port_name) {
17372                                 uint32_t _relative_save_offset;
17373                                 _relative_save_offset = ndr->offset;
17374                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17375                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17376                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17377                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17378                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17379                                 if (ndr->offset > ndr->relative_highest_offset) {
17380                                         ndr->relative_highest_offset = ndr->offset;
17381                                 }
17382                                 ndr->offset = _relative_save_offset;
17383                         }
17384                         ndr->flags = _flags_save_string;
17385                 }
17386                 {
17387                         uint32_t _flags_save_string = ndr->flags;
17388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17389                         if (r->monitor_name) {
17390                                 uint32_t _relative_save_offset;
17391                                 _relative_save_offset = ndr->offset;
17392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17393                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17394                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17397                                 if (ndr->offset > ndr->relative_highest_offset) {
17398                                         ndr->relative_highest_offset = ndr->offset;
17399                                 }
17400                                 ndr->offset = _relative_save_offset;
17401                         }
17402                         ndr->flags = _flags_save_string;
17403                 }
17404                 {
17405                         uint32_t _flags_save_string = ndr->flags;
17406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17407                         if (r->description) {
17408                                 uint32_t _relative_save_offset;
17409                                 _relative_save_offset = ndr->offset;
17410                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17411                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17412                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17413                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17414                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17415                                 if (ndr->offset > ndr->relative_highest_offset) {
17416                                         ndr->relative_highest_offset = ndr->offset;
17417                                 }
17418                                 ndr->offset = _relative_save_offset;
17419                         }
17420                         ndr->flags = _flags_save_string;
17421                 }
17422         }
17423         return NDR_ERR_SUCCESS;
17424 }
17425
17426 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17427 {
17428         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17429         ndr->depth++;
17430         ndr_print_ptr(ndr, "port_name", r->port_name);
17431         ndr->depth++;
17432         if (r->port_name) {
17433                 ndr_print_string(ndr, "port_name", r->port_name);
17434         }
17435         ndr->depth--;
17436         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17437         ndr->depth++;
17438         if (r->monitor_name) {
17439                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17440         }
17441         ndr->depth--;
17442         ndr_print_ptr(ndr, "description", r->description);
17443         ndr->depth++;
17444         if (r->description) {
17445                 ndr_print_string(ndr, "description", r->description);
17446         }
17447         ndr->depth--;
17448         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17449         ndr_print_uint32(ndr, "reserved", r->reserved);
17450         ndr->depth--;
17451 }
17452
17453 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17454 {
17455         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17456 }
17457
17458 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17459 {
17460         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17461         return NDR_ERR_SUCCESS;
17462 }
17463
17464 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17465 {
17466         uint32_t v;
17467         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17468         *r = v;
17469         return NDR_ERR_SUCCESS;
17470 }
17471
17472 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17473 {
17474         const char *val = NULL;
17475
17476         switch (r) {
17477                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17478                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17479                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17480                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17481                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17482                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17483                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17484                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17485                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17486                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17487                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17488                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17489                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17490         }
17491         ndr_print_enum(ndr, name, "ENUM", val, r);
17492 }
17493
17494 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17495 {
17496         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17497         return NDR_ERR_SUCCESS;
17498 }
17499
17500 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17501 {
17502         uint32_t v;
17503         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17504         *r = v;
17505         return NDR_ERR_SUCCESS;
17506 }
17507
17508 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17509 {
17510         const char *val = NULL;
17511
17512         switch (r) {
17513                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17514                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17515                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17516         }
17517         ndr_print_enum(ndr, name, "ENUM", val, r);
17518 }
17519
17520 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17521 {
17522         if (ndr_flags & NDR_SCALARS) {
17523                 NDR_CHECK(ndr_push_align(ndr, 5));
17524                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17525                 {
17526                         uint32_t _flags_save_string = ndr->flags;
17527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17528                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17529                         ndr->flags = _flags_save_string;
17530                 }
17531                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17532                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17533         }
17534         if (ndr_flags & NDR_BUFFERS) {
17535                 {
17536                         uint32_t _flags_save_string = ndr->flags;
17537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17538                         if (r->status_string) {
17539                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->status_string));
17540                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17541                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->status_string));
17542                         }
17543                         ndr->flags = _flags_save_string;
17544                 }
17545         }
17546         return NDR_ERR_SUCCESS;
17547 }
17548
17549 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17550 {
17551         uint32_t _ptr_status_string;
17552         TALLOC_CTX *_mem_save_status_string_0;
17553         if (ndr_flags & NDR_SCALARS) {
17554                 NDR_CHECK(ndr_pull_align(ndr, 5));
17555                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17556                 {
17557                         uint32_t _flags_save_string = ndr->flags;
17558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17560                         if (_ptr_status_string) {
17561                                 NDR_PULL_ALLOC(ndr, r->status_string);
17562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17563                         } else {
17564                                 r->status_string = NULL;
17565                         }
17566                         ndr->flags = _flags_save_string;
17567                 }
17568                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17569                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17570         }
17571         if (ndr_flags & NDR_BUFFERS) {
17572                 {
17573                         uint32_t _flags_save_string = ndr->flags;
17574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17575                         if (r->status_string) {
17576                                 uint32_t _relative_save_offset;
17577                                 _relative_save_offset = ndr->offset;
17578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17579                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17580                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17581                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17583                                 if (ndr->offset > ndr->relative_highest_offset) {
17584                                         ndr->relative_highest_offset = ndr->offset;
17585                                 }
17586                                 ndr->offset = _relative_save_offset;
17587                         }
17588                         ndr->flags = _flags_save_string;
17589                 }
17590         }
17591         return NDR_ERR_SUCCESS;
17592 }
17593
17594 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17595 {
17596         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17597         ndr->depth++;
17598         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17599         ndr_print_ptr(ndr, "status_string", r->status_string);
17600         ndr->depth++;
17601         if (r->status_string) {
17602                 ndr_print_string(ndr, "status_string", r->status_string);
17603         }
17604         ndr->depth--;
17605         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17606         ndr->depth--;
17607 }
17608
17609 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17610 {
17611         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17612 }
17613
17614 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17615 {
17616         if (ndr_flags & NDR_SCALARS) {
17617                 NDR_CHECK(ndr_push_align(ndr, 5));
17618                 {
17619                         uint32_t _flags_save_string = ndr->flags;
17620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17621                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17622                         ndr->flags = _flags_save_string;
17623                 }
17624                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17625                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17626         }
17627         if (ndr_flags & NDR_BUFFERS) {
17628                 {
17629                         uint32_t _flags_save_string = ndr->flags;
17630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17631                         if (r->port_name) {
17632                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17633                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17634                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17635                         }
17636                         ndr->flags = _flags_save_string;
17637                 }
17638         }
17639         return NDR_ERR_SUCCESS;
17640 }
17641
17642 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17643 {
17644         uint32_t _ptr_port_name;
17645         TALLOC_CTX *_mem_save_port_name_0;
17646         if (ndr_flags & NDR_SCALARS) {
17647                 NDR_CHECK(ndr_pull_align(ndr, 5));
17648                 {
17649                         uint32_t _flags_save_string = ndr->flags;
17650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17651                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17652                         if (_ptr_port_name) {
17653                                 NDR_PULL_ALLOC(ndr, r->port_name);
17654                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17655                         } else {
17656                                 r->port_name = NULL;
17657                         }
17658                         ndr->flags = _flags_save_string;
17659                 }
17660                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17661                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17662         }
17663         if (ndr_flags & NDR_BUFFERS) {
17664                 {
17665                         uint32_t _flags_save_string = ndr->flags;
17666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17667                         if (r->port_name) {
17668                                 uint32_t _relative_save_offset;
17669                                 _relative_save_offset = ndr->offset;
17670                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17671                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17672                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17673                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17674                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17675                                 if (ndr->offset > ndr->relative_highest_offset) {
17676                                         ndr->relative_highest_offset = ndr->offset;
17677                                 }
17678                                 ndr->offset = _relative_save_offset;
17679                         }
17680                         ndr->flags = _flags_save_string;
17681                 }
17682         }
17683         return NDR_ERR_SUCCESS;
17684 }
17685
17686 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17687 {
17688         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17689         ndr->depth++;
17690         ndr_print_ptr(ndr, "port_name", r->port_name);
17691         ndr->depth++;
17692         if (r->port_name) {
17693                 ndr_print_string(ndr, "port_name", r->port_name);
17694         }
17695         ndr->depth--;
17696         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17697         ndr->depth--;
17698 }
17699
17700 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17701 {
17702         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17703 }
17704
17705 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17706 {
17707         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17708         {
17709                 uint32_t _flags_save_UNION = ndr->flags;
17710                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17711                 if (ndr_flags & NDR_SCALARS) {
17712                         int level = ndr_push_get_switch_value(ndr, r);
17713                         NDR_CHECK(ndr_push_union_align(ndr, 5));
17714                         switch (level) {
17715                                 case 1: {
17716                                         NDR_CHECK(ndr_push_align(ndr, 5));
17717                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17718                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17719                                 break; }
17720
17721                                 case 2: {
17722                                         NDR_CHECK(ndr_push_align(ndr, 5));
17723                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17724                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17725                                 break; }
17726
17727                                 case 3: {
17728                                         NDR_CHECK(ndr_push_align(ndr, 5));
17729                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17730                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17731                                 break; }
17732
17733                                 case 0xff: {
17734                                         NDR_CHECK(ndr_push_align(ndr, 5));
17735                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17736                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17737                                 break; }
17738
17739                                 default: {
17740                                 break; }
17741
17742                         }
17743                 }
17744                 if (ndr_flags & NDR_BUFFERS) {
17745                         int level = ndr_push_get_switch_value(ndr, r);
17746                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17747                         switch (level) {
17748                                 case 1:
17749                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17750                                 break;
17751
17752                                 case 2:
17753                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17754                                 break;
17755
17756                                 case 3:
17757                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17758                                 break;
17759
17760                                 case 0xff:
17761                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17762                                 break;
17763
17764                                 default:
17765                                 break;
17766
17767                         }
17768                 }
17769                 ndr->flags = _flags_save_UNION;
17770         }
17771         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17772         return NDR_ERR_SUCCESS;
17773 }
17774
17775 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17776 {
17777         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17778         int level;
17779         {
17780                 uint32_t _flags_save_UNION = ndr->flags;
17781                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17782                 level = ndr_pull_get_switch_value(ndr, r);
17783                 if (ndr_flags & NDR_SCALARS) {
17784                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
17785                         switch (level) {
17786                                 case 1: {
17787                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17788                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17789                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17790                                 break; }
17791
17792                                 case 2: {
17793                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17794                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17795                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17796                                 break; }
17797
17798                                 case 3: {
17799                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17800                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17801                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17802                                 break; }
17803
17804                                 case 0xff: {
17805                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17806                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17807                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17808                                 break; }
17809
17810                                 default: {
17811                                 break; }
17812
17813                         }
17814                 }
17815                 if (ndr_flags & NDR_BUFFERS) {
17816                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17817                         switch (level) {
17818                                 case 1:
17819                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17820                                 break;
17821
17822                                 case 2:
17823                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17824                                 break;
17825
17826                                 case 3:
17827                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17828                                 break;
17829
17830                                 case 0xff:
17831                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17832                                 break;
17833
17834                                 default:
17835                                 break;
17836
17837                         }
17838                 }
17839                 ndr->flags = _flags_save_UNION;
17840         }
17841         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17842         return NDR_ERR_SUCCESS;
17843 }
17844
17845 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17846 {
17847         int level;
17848         {
17849                 uint32_t _flags_save_UNION = ndr->flags;
17850                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17851                 level = ndr_print_get_switch_value(ndr, r);
17852                 ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17853                 switch (level) {
17854                         case 1:
17855                                 ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17856                         break;
17857
17858                         case 2:
17859                                 ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17860                         break;
17861
17862                         case 3:
17863                                 ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17864                         break;
17865
17866                         case 0xff:
17867                                 ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17868                         break;
17869
17870                         default:
17871                         break;
17872
17873                 }
17874                 ndr->flags = _flags_save_UNION;
17875         }
17876 }
17877
17878 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17879 {
17880         if (ndr_flags & NDR_SCALARS) {
17881                 NDR_CHECK(ndr_push_align(ndr, 5));
17882                 {
17883                         uint32_t _flags_save_string = ndr->flags;
17884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17885                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17886                         ndr->flags = _flags_save_string;
17887                 }
17888                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17889         }
17890         if (ndr_flags & NDR_BUFFERS) {
17891                 {
17892                         uint32_t _flags_save_string = ndr->flags;
17893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17894                         if (r->monitor_name) {
17895                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17896                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17897                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17898                         }
17899                         ndr->flags = _flags_save_string;
17900                 }
17901         }
17902         return NDR_ERR_SUCCESS;
17903 }
17904
17905 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17906 {
17907         uint32_t _ptr_monitor_name;
17908         TALLOC_CTX *_mem_save_monitor_name_0;
17909         if (ndr_flags & NDR_SCALARS) {
17910                 NDR_CHECK(ndr_pull_align(ndr, 5));
17911                 {
17912                         uint32_t _flags_save_string = ndr->flags;
17913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17914                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17915                         if (_ptr_monitor_name) {
17916                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17917                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17918                         } else {
17919                                 r->monitor_name = NULL;
17920                         }
17921                         ndr->flags = _flags_save_string;
17922                 }
17923                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17924         }
17925         if (ndr_flags & NDR_BUFFERS) {
17926                 {
17927                         uint32_t _flags_save_string = ndr->flags;
17928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17929                         if (r->monitor_name) {
17930                                 uint32_t _relative_save_offset;
17931                                 _relative_save_offset = ndr->offset;
17932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17933                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17934                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17937                                 if (ndr->offset > ndr->relative_highest_offset) {
17938                                         ndr->relative_highest_offset = ndr->offset;
17939                                 }
17940                                 ndr->offset = _relative_save_offset;
17941                         }
17942                         ndr->flags = _flags_save_string;
17943                 }
17944         }
17945         return NDR_ERR_SUCCESS;
17946 }
17947
17948 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17949 {
17950         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17951         ndr->depth++;
17952         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17953         ndr->depth++;
17954         if (r->monitor_name) {
17955                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17956         }
17957         ndr->depth--;
17958         ndr->depth--;
17959 }
17960
17961 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17962 {
17963         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17964 }
17965
17966 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17967 {
17968         if (ndr_flags & NDR_SCALARS) {
17969                 NDR_CHECK(ndr_push_align(ndr, 5));
17970                 {
17971                         uint32_t _flags_save_string = ndr->flags;
17972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17973                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17974                         ndr->flags = _flags_save_string;
17975                 }
17976                 {
17977                         uint32_t _flags_save_string = ndr->flags;
17978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17979                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17980                         ndr->flags = _flags_save_string;
17981                 }
17982                 {
17983                         uint32_t _flags_save_string = ndr->flags;
17984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17985                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17986                         ndr->flags = _flags_save_string;
17987                 }
17988                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17989         }
17990         if (ndr_flags & NDR_BUFFERS) {
17991                 {
17992                         uint32_t _flags_save_string = ndr->flags;
17993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17994                         if (r->monitor_name) {
17995                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17996                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17997                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17998                         }
17999                         ndr->flags = _flags_save_string;
18000                 }
18001                 {
18002                         uint32_t _flags_save_string = ndr->flags;
18003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18004                         if (r->environment) {
18005                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->environment));
18006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
18007                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->environment));
18008                         }
18009                         ndr->flags = _flags_save_string;
18010                 }
18011                 {
18012                         uint32_t _flags_save_string = ndr->flags;
18013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18014                         if (r->dll_name) {
18015                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dll_name));
18016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18017                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dll_name));
18018                         }
18019                         ndr->flags = _flags_save_string;
18020                 }
18021         }
18022         return NDR_ERR_SUCCESS;
18023 }
18024
18025 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
18026 {
18027         uint32_t _ptr_monitor_name;
18028         TALLOC_CTX *_mem_save_monitor_name_0;
18029         uint32_t _ptr_environment;
18030         TALLOC_CTX *_mem_save_environment_0;
18031         uint32_t _ptr_dll_name;
18032         TALLOC_CTX *_mem_save_dll_name_0;
18033         if (ndr_flags & NDR_SCALARS) {
18034                 NDR_CHECK(ndr_pull_align(ndr, 5));
18035                 {
18036                         uint32_t _flags_save_string = ndr->flags;
18037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18038                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
18039                         if (_ptr_monitor_name) {
18040                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
18041                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
18042                         } else {
18043                                 r->monitor_name = NULL;
18044                         }
18045                         ndr->flags = _flags_save_string;
18046                 }
18047                 {
18048                         uint32_t _flags_save_string = ndr->flags;
18049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18050                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18051                         if (_ptr_environment) {
18052                                 NDR_PULL_ALLOC(ndr, r->environment);
18053                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
18054                         } else {
18055                                 r->environment = NULL;
18056                         }
18057                         ndr->flags = _flags_save_string;
18058                 }
18059                 {
18060                         uint32_t _flags_save_string = ndr->flags;
18061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18062                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
18063                         if (_ptr_dll_name) {
18064                                 NDR_PULL_ALLOC(ndr, r->dll_name);
18065                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
18066                         } else {
18067                                 r->dll_name = NULL;
18068                         }
18069                         ndr->flags = _flags_save_string;
18070                 }
18071                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18072         }
18073         if (ndr_flags & NDR_BUFFERS) {
18074                 {
18075                         uint32_t _flags_save_string = ndr->flags;
18076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18077                         if (r->monitor_name) {
18078                                 uint32_t _relative_save_offset;
18079                                 _relative_save_offset = ndr->offset;
18080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
18081                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18082                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
18083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
18084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
18085                                 if (ndr->offset > ndr->relative_highest_offset) {
18086                                         ndr->relative_highest_offset = ndr->offset;
18087                                 }
18088                                 ndr->offset = _relative_save_offset;
18089                         }
18090                         ndr->flags = _flags_save_string;
18091                 }
18092                 {
18093                         uint32_t _flags_save_string = ndr->flags;
18094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18095                         if (r->environment) {
18096                                 uint32_t _relative_save_offset;
18097                                 _relative_save_offset = ndr->offset;
18098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
18099                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18100                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
18101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
18102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18103                                 if (ndr->offset > ndr->relative_highest_offset) {
18104                                         ndr->relative_highest_offset = ndr->offset;
18105                                 }
18106                                 ndr->offset = _relative_save_offset;
18107                         }
18108                         ndr->flags = _flags_save_string;
18109                 }
18110                 {
18111                         uint32_t _flags_save_string = ndr->flags;
18112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18113                         if (r->dll_name) {
18114                                 uint32_t _relative_save_offset;
18115                                 _relative_save_offset = ndr->offset;
18116                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
18117                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18118                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
18119                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18120                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
18121                                 if (ndr->offset > ndr->relative_highest_offset) {
18122                                         ndr->relative_highest_offset = ndr->offset;
18123                                 }
18124                                 ndr->offset = _relative_save_offset;
18125                         }
18126                         ndr->flags = _flags_save_string;
18127                 }
18128         }
18129         return NDR_ERR_SUCCESS;
18130 }
18131
18132 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
18133 {
18134         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
18135         ndr->depth++;
18136         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
18137         ndr->depth++;
18138         if (r->monitor_name) {
18139                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
18140         }
18141         ndr->depth--;
18142         ndr_print_ptr(ndr, "environment", r->environment);
18143         ndr->depth++;
18144         if (r->environment) {
18145                 ndr_print_string(ndr, "environment", r->environment);
18146         }
18147         ndr->depth--;
18148         ndr_print_ptr(ndr, "dll_name", r->dll_name);
18149         ndr->depth++;
18150         if (r->dll_name) {
18151                 ndr_print_string(ndr, "dll_name", r->dll_name);
18152         }
18153         ndr->depth--;
18154         ndr->depth--;
18155 }
18156
18157 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
18158 {
18159         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
18160 }
18161
18162 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
18163 {
18164         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18165         {
18166                 uint32_t _flags_save_UNION = ndr->flags;
18167                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18168                 if (ndr_flags & NDR_SCALARS) {
18169                         int level = ndr_push_get_switch_value(ndr, r);
18170                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18171                         switch (level) {
18172                                 case 1: {
18173                                         NDR_CHECK(ndr_push_align(ndr, 5));
18174                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18175                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18176                                 break; }
18177
18178                                 case 2: {
18179                                         NDR_CHECK(ndr_push_align(ndr, 5));
18180                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18181                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18182                                 break; }
18183
18184                                 default: {
18185                                 break; }
18186
18187                         }
18188                 }
18189                 if (ndr_flags & NDR_BUFFERS) {
18190                         int level = ndr_push_get_switch_value(ndr, r);
18191                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18192                         switch (level) {
18193                                 case 1:
18194                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18195                                 break;
18196
18197                                 case 2:
18198                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18199                                 break;
18200
18201                                 default:
18202                                 break;
18203
18204                         }
18205                 }
18206                 ndr->flags = _flags_save_UNION;
18207         }
18208         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18209         return NDR_ERR_SUCCESS;
18210 }
18211
18212 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
18213 {
18214         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18215         int level;
18216         {
18217                 uint32_t _flags_save_UNION = ndr->flags;
18218                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18219                 level = ndr_pull_get_switch_value(ndr, r);
18220                 if (ndr_flags & NDR_SCALARS) {
18221                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18222                         switch (level) {
18223                                 case 1: {
18224                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18225                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18226                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18227                                 break; }
18228
18229                                 case 2: {
18230                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18231                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18232                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18233                                 break; }
18234
18235                                 default: {
18236                                 break; }
18237
18238                         }
18239                 }
18240                 if (ndr_flags & NDR_BUFFERS) {
18241                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18242                         switch (level) {
18243                                 case 1:
18244                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18245                                 break;
18246
18247                                 case 2:
18248                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18249                                 break;
18250
18251                                 default:
18252                                 break;
18253
18254                         }
18255                 }
18256                 ndr->flags = _flags_save_UNION;
18257         }
18258         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18259         return NDR_ERR_SUCCESS;
18260 }
18261
18262 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
18263 {
18264         int level;
18265         {
18266                 uint32_t _flags_save_UNION = ndr->flags;
18267                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18268                 level = ndr_print_get_switch_value(ndr, r);
18269                 ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
18270                 switch (level) {
18271                         case 1:
18272                                 ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
18273                         break;
18274
18275                         case 2:
18276                                 ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
18277                         break;
18278
18279                         default:
18280                         break;
18281
18282                 }
18283                 ndr->flags = _flags_save_UNION;
18284         }
18285 }
18286
18287 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
18288 {
18289         if (ndr_flags & NDR_SCALARS) {
18290                 NDR_CHECK(ndr_push_align(ndr, 5));
18291                 {
18292                         uint32_t _flags_save_string = ndr->flags;
18293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
18295                         ndr->flags = _flags_save_string;
18296                 }
18297                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18298         }
18299         if (ndr_flags & NDR_BUFFERS) {
18300                 {
18301                         uint32_t _flags_save_string = ndr->flags;
18302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18303                         if (r->name_array) {
18304                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name_array));
18305                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
18306                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name_array));
18307                         }
18308                         ndr->flags = _flags_save_string;
18309                 }
18310         }
18311         return NDR_ERR_SUCCESS;
18312 }
18313
18314 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
18315 {
18316         uint32_t _ptr_name_array;
18317         TALLOC_CTX *_mem_save_name_array_0;
18318         if (ndr_flags & NDR_SCALARS) {
18319                 NDR_CHECK(ndr_pull_align(ndr, 5));
18320                 {
18321                         uint32_t _flags_save_string = ndr->flags;
18322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18323                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
18324                         if (_ptr_name_array) {
18325                                 NDR_PULL_ALLOC(ndr, r->name_array);
18326                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
18327                         } else {
18328                                 r->name_array = NULL;
18329                         }
18330                         ndr->flags = _flags_save_string;
18331                 }
18332                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18333         }
18334         if (ndr_flags & NDR_BUFFERS) {
18335                 {
18336                         uint32_t _flags_save_string = ndr->flags;
18337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18338                         if (r->name_array) {
18339                                 uint32_t _relative_save_offset;
18340                                 _relative_save_offset = ndr->offset;
18341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
18342                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
18343                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
18344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
18345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
18346                                 if (ndr->offset > ndr->relative_highest_offset) {
18347                                         ndr->relative_highest_offset = ndr->offset;
18348                                 }
18349                                 ndr->offset = _relative_save_offset;
18350                         }
18351                         ndr->flags = _flags_save_string;
18352                 }
18353         }
18354         return NDR_ERR_SUCCESS;
18355 }
18356
18357 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
18358 {
18359         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
18360         ndr->depth++;
18361         ndr_print_ptr(ndr, "name_array", r->name_array);
18362         ndr->depth++;
18363         if (r->name_array) {
18364                 ndr_print_string(ndr, "name_array", r->name_array);
18365         }
18366         ndr->depth--;
18367         ndr->depth--;
18368 }
18369
18370 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18371 {
18372         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
18373 }
18374
18375 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
18376 {
18377         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18378         {
18379                 uint32_t _flags_save_UNION = ndr->flags;
18380                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18381                 if (ndr_flags & NDR_SCALARS) {
18382                         int level = ndr_push_get_switch_value(ndr, r);
18383                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18384                         switch (level) {
18385                                 case 1: {
18386                                         NDR_CHECK(ndr_push_align(ndr, 5));
18387                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18388                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18389                                 break; }
18390
18391                                 default: {
18392                                 break; }
18393
18394                         }
18395                 }
18396                 if (ndr_flags & NDR_BUFFERS) {
18397                         int level = ndr_push_get_switch_value(ndr, r);
18398                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18399                         switch (level) {
18400                                 case 1:
18401                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18402                                 break;
18403
18404                                 default:
18405                                 break;
18406
18407                         }
18408                 }
18409                 ndr->flags = _flags_save_UNION;
18410         }
18411         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18412         return NDR_ERR_SUCCESS;
18413 }
18414
18415 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
18416 {
18417         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18418         int level;
18419         {
18420                 uint32_t _flags_save_UNION = ndr->flags;
18421                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18422                 level = ndr_pull_get_switch_value(ndr, r);
18423                 if (ndr_flags & NDR_SCALARS) {
18424                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18425                         switch (level) {
18426                                 case 1: {
18427                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18428                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18429                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18430                                 break; }
18431
18432                                 default: {
18433                                 break; }
18434
18435                         }
18436                 }
18437                 if (ndr_flags & NDR_BUFFERS) {
18438                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18439                         switch (level) {
18440                                 case 1:
18441                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18442                                 break;
18443
18444                                 default:
18445                                 break;
18446
18447                         }
18448                 }
18449                 ndr->flags = _flags_save_UNION;
18450         }
18451         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18452         return NDR_ERR_SUCCESS;
18453 }
18454
18455 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18456 {
18457         int level;
18458         {
18459                 uint32_t _flags_save_UNION = ndr->flags;
18460                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18461                 level = ndr_print_get_switch_value(ndr, r);
18462                 ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18463                 switch (level) {
18464                         case 1:
18465                                 ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18466                         break;
18467
18468                         default:
18469                         break;
18470
18471                 }
18472                 ndr->flags = _flags_save_UNION;
18473         }
18474 }
18475
18476 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18477 {
18478         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18479         return NDR_ERR_SUCCESS;
18480 }
18481
18482 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18483 {
18484         uint32_t v;
18485         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18486         *r = v;
18487         return NDR_ERR_SUCCESS;
18488 }
18489
18490 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18491 {
18492         ndr_print_uint32(ndr, name, r);
18493         ndr->depth++;
18494         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18495         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18496         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18497         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18498         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18499         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18500         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18501         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18502         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18503         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18504         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18505         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18506         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18507         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18508         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18509         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18510         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18511         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18512         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18513         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18514         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18515         ndr->depth--;
18516 }
18517
18518 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18519 {
18520         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18521         return NDR_ERR_SUCCESS;
18522 }
18523
18524 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18525 {
18526         uint16_t v;
18527         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18528         *r = v;
18529         return NDR_ERR_SUCCESS;
18530 }
18531
18532 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18533 {
18534         const char *val = NULL;
18535
18536         switch (r) {
18537                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18538                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18539                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18540                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18541                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18542                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18543                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18544                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18545                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18546                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18547                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18548                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18549                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18550                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18551                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18552                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18553                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18554                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18555                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18556                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18557                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18558                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18559                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18560                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18561         }
18562         ndr_print_enum(ndr, name, "ENUM", val, r);
18563 }
18564
18565 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18566 {
18567         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18568         return NDR_ERR_SUCCESS;
18569 }
18570
18571 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18572 {
18573         uint16_t v;
18574         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18575         *r = v;
18576         return NDR_ERR_SUCCESS;
18577 }
18578
18579 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18580 {
18581         const char *val = NULL;
18582
18583         switch (r) {
18584                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18585                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18586                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18587                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18588                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18589                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18590                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18591                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18592                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18593                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18594                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18595                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18596                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18597                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18598                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18599                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18600                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18601                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18602                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18603                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18604                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18605                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18606                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18607                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18608                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18609                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18610                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18611                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18612         }
18613         ndr_print_enum(ndr, name, "ENUM", val, r);
18614 }
18615
18616 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18617 {
18618         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18619         return NDR_ERR_SUCCESS;
18620 }
18621
18622 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18623 {
18624         uint16_t v;
18625         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18626         *r = v;
18627         return NDR_ERR_SUCCESS;
18628 }
18629
18630 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18631 {
18632         const char *val = NULL;
18633
18634         switch (r) {
18635                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18636                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18637         }
18638         ndr_print_enum(ndr, name, "ENUM", val, r);
18639 }
18640
18641 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18642 {
18643         if (ndr_flags & NDR_SCALARS) {
18644                 int level = ndr_push_get_switch_value(ndr, r);
18645                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18646                 switch (level) {
18647                         case PRINTER_NOTIFY_TYPE: {
18648                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18649                         break; }
18650
18651                         case JOB_NOTIFY_TYPE: {
18652                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18653                         break; }
18654
18655                         default: {
18656                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18657                         break; }
18658
18659                 }
18660         }
18661         if (ndr_flags & NDR_BUFFERS) {
18662                 int level = ndr_push_get_switch_value(ndr, r);
18663                 switch (level) {
18664                         case PRINTER_NOTIFY_TYPE:
18665                         break;
18666
18667                         case JOB_NOTIFY_TYPE:
18668                         break;
18669
18670                         default:
18671                         break;
18672
18673                 }
18674         }
18675         return NDR_ERR_SUCCESS;
18676 }
18677
18678 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18679 {
18680         int level;
18681         level = ndr_pull_get_switch_value(ndr, r);
18682         if (ndr_flags & NDR_SCALARS) {
18683                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18684                 switch (level) {
18685                         case PRINTER_NOTIFY_TYPE: {
18686                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18687                         break; }
18688
18689                         case JOB_NOTIFY_TYPE: {
18690                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18691                         break; }
18692
18693                         default: {
18694                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18695                         break; }
18696
18697                 }
18698         }
18699         if (ndr_flags & NDR_BUFFERS) {
18700                 switch (level) {
18701                         case PRINTER_NOTIFY_TYPE:
18702                         break;
18703
18704                         case JOB_NOTIFY_TYPE:
18705                         break;
18706
18707                         default:
18708                         break;
18709
18710                 }
18711         }
18712         return NDR_ERR_SUCCESS;
18713 }
18714
18715 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18716 {
18717         uint32_t cntr_fields_1;
18718         if (ndr_flags & NDR_SCALARS) {
18719                 NDR_CHECK(ndr_push_align(ndr, 5));
18720                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18721                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18726                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18727         }
18728         if (ndr_flags & NDR_BUFFERS) {
18729                 if (r->fields) {
18730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18731                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18732                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18733                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18734                         }
18735                 }
18736         }
18737         return NDR_ERR_SUCCESS;
18738 }
18739
18740 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18741 {
18742         uint32_t _ptr_fields;
18743         uint32_t cntr_fields_1;
18744         TALLOC_CTX *_mem_save_fields_0;
18745         TALLOC_CTX *_mem_save_fields_1;
18746         if (ndr_flags & NDR_SCALARS) {
18747                 NDR_CHECK(ndr_pull_align(ndr, 5));
18748                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18749                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18754                 if (_ptr_fields) {
18755                         NDR_PULL_ALLOC(ndr, r->fields);
18756                 } else {
18757                         r->fields = NULL;
18758                 }
18759                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18760         }
18761         if (ndr_flags & NDR_BUFFERS) {
18762                 if (r->fields) {
18763                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18764                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18766                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18767                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18768                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18769                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18770                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18771                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18772                         }
18773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18775                 }
18776                 if (r->fields) {
18777                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18778                 }
18779         }
18780         return NDR_ERR_SUCCESS;
18781 }
18782
18783 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18784 {
18785         uint32_t cntr_fields_1;
18786         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18787         ndr->depth++;
18788         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18789         ndr_print_uint16(ndr, "u1", r->u1);
18790         ndr_print_uint32(ndr, "u2", r->u2);
18791         ndr_print_uint32(ndr, "u3", r->u3);
18792         ndr_print_uint32(ndr, "count", r->count);
18793         ndr_print_ptr(ndr, "fields", r->fields);
18794         ndr->depth++;
18795         if (r->fields) {
18796                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18797                 ndr->depth++;
18798                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18799                         char *idx_1=NULL;
18800                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18801                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18802                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18803                                 free(idx_1);
18804                         }
18805                 }
18806                 ndr->depth--;
18807         }
18808         ndr->depth--;
18809         ndr->depth--;
18810 }
18811
18812 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18813 {
18814         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18815         return NDR_ERR_SUCCESS;
18816 }
18817
18818 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18819 {
18820         uint32_t v;
18821         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18822         *r = v;
18823         return NDR_ERR_SUCCESS;
18824 }
18825
18826 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18827 {
18828         ndr_print_uint32(ndr, name, r);
18829         ndr->depth++;
18830         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18831         ndr->depth--;
18832 }
18833
18834 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18835 {
18836         uint32_t cntr_types_1;
18837         if (ndr_flags & NDR_SCALARS) {
18838                 NDR_CHECK(ndr_push_align(ndr, 5));
18839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18840                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18843                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18844         }
18845         if (ndr_flags & NDR_BUFFERS) {
18846                 if (r->types) {
18847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18848                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18849                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18850                         }
18851                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18852                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18853                         }
18854                 }
18855         }
18856         return NDR_ERR_SUCCESS;
18857 }
18858
18859 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18860 {
18861         uint32_t _ptr_types;
18862         uint32_t cntr_types_1;
18863         TALLOC_CTX *_mem_save_types_0;
18864         TALLOC_CTX *_mem_save_types_1;
18865         if (ndr_flags & NDR_SCALARS) {
18866                 NDR_CHECK(ndr_pull_align(ndr, 5));
18867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18868                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18871                 if (_ptr_types) {
18872                         NDR_PULL_ALLOC(ndr, r->types);
18873                 } else {
18874                         r->types = NULL;
18875                 }
18876                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18877         }
18878         if (ndr_flags & NDR_BUFFERS) {
18879                 if (r->types) {
18880                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18881                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18882                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18883                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18884                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18885                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18886                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18887                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18888                         }
18889                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18890                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18891                         }
18892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18893                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18894                 }
18895                 if (r->types) {
18896                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18897                 }
18898         }
18899         return NDR_ERR_SUCCESS;
18900 }
18901
18902 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18903 {
18904         uint32_t cntr_types_1;
18905         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18906         ndr->depth++;
18907         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18908         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18909         ndr_print_uint32(ndr, "count", r->count);
18910         ndr_print_ptr(ndr, "types", r->types);
18911         ndr->depth++;
18912         if (r->types) {
18913                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18914                 ndr->depth++;
18915                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18916                         char *idx_1=NULL;
18917                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18918                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18919                                 free(idx_1);
18920                         }
18921                 }
18922                 ndr->depth--;
18923         }
18924         ndr->depth--;
18925         ndr->depth--;
18926 }
18927
18928 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18929 {
18930         if (ndr_flags & NDR_SCALARS) {
18931                 NDR_CHECK(ndr_push_align(ndr, 5));
18932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18934                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18935         }
18936         if (ndr_flags & NDR_BUFFERS) {
18937                 if (r->string) {
18938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18939                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18940                 }
18941         }
18942         return NDR_ERR_SUCCESS;
18943 }
18944
18945 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18946 {
18947         uint32_t _ptr_string;
18948         TALLOC_CTX *_mem_save_string_0;
18949         if (ndr_flags & NDR_SCALARS) {
18950                 NDR_CHECK(ndr_pull_align(ndr, 5));
18951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18952                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18953                 if (_ptr_string) {
18954                         NDR_PULL_ALLOC(ndr, r->string);
18955                 } else {
18956                         r->string = NULL;
18957                 }
18958                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18959         }
18960         if (ndr_flags & NDR_BUFFERS) {
18961                 if (r->string) {
18962                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18963                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18967                 }
18968                 if (r->string) {
18969                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18970                 }
18971         }
18972         return NDR_ERR_SUCCESS;
18973 }
18974
18975 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18976 {
18977         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18978         ndr->depth++;
18979         ndr_print_uint32(ndr, "size", r->size);
18980         ndr_print_ptr(ndr, "string", r->string);
18981         ndr->depth++;
18982         if (r->string) {
18983                 ndr_print_string(ndr, "string", r->string);
18984         }
18985         ndr->depth--;
18986         ndr->depth--;
18987 }
18988
18989 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18990 {
18991         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18992         return NDR_ERR_SUCCESS;
18993 }
18994
18995 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18996 {
18997         uint32_t v;
18998         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18999         *r = v;
19000         return NDR_ERR_SUCCESS;
19001 }
19002
19003 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
19004 {
19005         const char *val = NULL;
19006
19007         switch (r) {
19008                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
19009                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
19010                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
19011                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
19012                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
19013         }
19014         ndr_print_enum(ndr, name, "ENUM", val, r);
19015 }
19016
19017 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
19018 {
19019         if (ndr_flags & NDR_SCALARS) {
19020                 int level = ndr_push_get_switch_value(ndr, r);
19021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19022                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19023                 switch (level) {
19024                         case 1: {
19025                                 uint32_t cntr_integer_0;
19026                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
19027                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
19028                                 }
19029                         break; }
19030
19031                         case 2: {
19032                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19033                         break; }
19034
19035                         case 3: {
19036                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19037                         break; }
19038
19039                         case 4: {
19040                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19041                         break; }
19042
19043                         case 5: {
19044                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19045                         break; }
19046
19047                         default:
19048                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19049                 }
19050         }
19051         if (ndr_flags & NDR_BUFFERS) {
19052                 int level = ndr_push_get_switch_value(ndr, r);
19053                 switch (level) {
19054                         case 1:
19055                         break;
19056
19057                         case 2:
19058                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19059                         break;
19060
19061                         case 3:
19062                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19063                         break;
19064
19065                         case 4:
19066                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19067                         break;
19068
19069                         case 5:
19070                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19071                         break;
19072
19073                         default:
19074                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19075                 }
19076         }
19077         return NDR_ERR_SUCCESS;
19078 }
19079
19080 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
19081 {
19082         int level;
19083         uint32_t _level;
19084         level = ndr_pull_get_switch_value(ndr, r);
19085         if (ndr_flags & NDR_SCALARS) {
19086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19087                 if (_level != level) {
19088                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19089                 }
19090                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19091                 switch (level) {
19092                         case 1: {
19093                                 uint32_t cntr_integer_0;
19094                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
19095                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
19096                                 }
19097                         break; }
19098
19099                         case 2: {
19100                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19101                         break; }
19102
19103                         case 3: {
19104                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19105                         break; }
19106
19107                         case 4: {
19108                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19109                         break; }
19110
19111                         case 5: {
19112                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19113                         break; }
19114
19115                         default:
19116                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19117                 }
19118         }
19119         if (ndr_flags & NDR_BUFFERS) {
19120                 switch (level) {
19121                         case 1:
19122                         break;
19123
19124                         case 2:
19125                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19126                         break;
19127
19128                         case 3:
19129                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19130                         break;
19131
19132                         case 4:
19133                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19134                         break;
19135
19136                         case 5:
19137                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19138                         break;
19139
19140                         default:
19141                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19142                 }
19143         }
19144         return NDR_ERR_SUCCESS;
19145 }
19146
19147 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
19148 {
19149         int level;
19150         uint32_t cntr_integer_0;
19151         level = ndr_print_get_switch_value(ndr, r);
19152         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
19153         switch (level) {
19154                 case 1:
19155                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
19156                         ndr->depth++;
19157                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
19158                                 char *idx_0=NULL;
19159                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
19160                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
19161                                         free(idx_0);
19162                                 }
19163                         }
19164                         ndr->depth--;
19165                 break;
19166
19167                 case 2:
19168                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
19169                 break;
19170
19171                 case 3:
19172                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
19173                 break;
19174
19175                 case 4:
19176                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
19177                 break;
19178
19179                 case 5:
19180                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
19181                 break;
19182
19183                 default:
19184                         ndr_print_bad_level(ndr, name, level);
19185         }
19186 }
19187
19188 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
19189 {
19190         if (ndr_flags & NDR_SCALARS) {
19191                 NDR_CHECK(ndr_push_align(ndr, 5));
19192                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
19193                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
19194                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19195                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
19196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
19197                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
19198                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19199                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19200         }
19201         if (ndr_flags & NDR_BUFFERS) {
19202                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19203         }
19204         return NDR_ERR_SUCCESS;
19205 }
19206
19207 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
19208 {
19209         if (ndr_flags & NDR_SCALARS) {
19210                 NDR_CHECK(ndr_pull_align(ndr, 5));
19211                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
19212                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
19213                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19214                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
19215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
19216                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
19217                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19218                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19219         }
19220         if (ndr_flags & NDR_BUFFERS) {
19221                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19222         }
19223         return NDR_ERR_SUCCESS;
19224 }
19225
19226 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
19227 {
19228         ndr_print_struct(ndr, name, "spoolss_Notify");
19229         ndr->depth++;
19230         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
19231         ndr_print_set_switch_value(ndr, &r->field, r->type);
19232         ndr_print_spoolss_Field(ndr, "field", &r->field);
19233         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
19234         ndr_print_uint32(ndr, "job_id", r->job_id);
19235         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
19236         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
19237         ndr->depth--;
19238 }
19239
19240 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
19241 {
19242         uint32_t cntr_notifies_0;
19243         if (ndr_flags & NDR_SCALARS) {
19244                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19245                 NDR_CHECK(ndr_push_align(ndr, 5));
19246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
19247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19249                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19250                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19251                 }
19252                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19253         }
19254         if (ndr_flags & NDR_BUFFERS) {
19255                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19256                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19257                 }
19258         }
19259         return NDR_ERR_SUCCESS;
19260 }
19261
19262 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
19263 {
19264         uint32_t cntr_notifies_0;
19265         TALLOC_CTX *_mem_save_notifies_0;
19266         if (ndr_flags & NDR_SCALARS) {
19267                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
19268                 NDR_CHECK(ndr_pull_align(ndr, 5));
19269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19272                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
19273                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19274                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19275                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19276                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19277                 }
19278                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19279                 if (r->notifies) {
19280                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
19281                 }
19282                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19283         }
19284         if (ndr_flags & NDR_BUFFERS) {
19285                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19286                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19287                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19288                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19289                 }
19290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19291         }
19292         return NDR_ERR_SUCCESS;
19293 }
19294
19295 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
19296 {
19297         uint32_t cntr_notifies_0;
19298         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
19299         ndr->depth++;
19300         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19301         ndr_print_uint32(ndr, "flags", r->flags);
19302         ndr_print_uint32(ndr, "count", r->count);
19303         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
19304         ndr->depth++;
19305         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
19306                 char *idx_0=NULL;
19307                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
19308                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
19309                         free(idx_0);
19310                 }
19311         }
19312         ndr->depth--;
19313         ndr->depth--;
19314 }
19315
19316 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
19317 {
19318         if (ndr_flags & NDR_SCALARS) {
19319                 int level = ndr_push_get_switch_value(ndr, r);
19320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19321                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19322                 switch (level) {
19323                         case 0: {
19324                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
19325                         break; }
19326
19327                         default:
19328                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19329                 }
19330         }
19331         if (ndr_flags & NDR_BUFFERS) {
19332                 int level = ndr_push_get_switch_value(ndr, r);
19333                 switch (level) {
19334                         case 0:
19335                                 if (r->info0) {
19336                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19337                                 }
19338                         break;
19339
19340                         default:
19341                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19342                 }
19343         }
19344         return NDR_ERR_SUCCESS;
19345 }
19346
19347 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
19348 {
19349         int level;
19350         uint32_t _level;
19351         TALLOC_CTX *_mem_save_info0_0;
19352         level = ndr_pull_get_switch_value(ndr, r);
19353         if (ndr_flags & NDR_SCALARS) {
19354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19355                 if (_level != level) {
19356                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19357                 }
19358                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19359                 switch (level) {
19360                         case 0: {
19361                                 uint32_t _ptr_info0;
19362                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
19363                                 if (_ptr_info0) {
19364                                         NDR_PULL_ALLOC(ndr, r->info0);
19365                                 } else {
19366                                         r->info0 = NULL;
19367                                 }
19368                         break; }
19369
19370                         default:
19371                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19372                 }
19373         }
19374         if (ndr_flags & NDR_BUFFERS) {
19375                 switch (level) {
19376                         case 0:
19377                                 if (r->info0) {
19378                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
19379                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
19380                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19381                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
19382                                 }
19383                         break;
19384
19385                         default:
19386                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19387                 }
19388         }
19389         return NDR_ERR_SUCCESS;
19390 }
19391
19392 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
19393 {
19394         int level;
19395         level = ndr_print_get_switch_value(ndr, r);
19396         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
19397         switch (level) {
19398                 case 0:
19399                         ndr_print_ptr(ndr, "info0", r->info0);
19400                         ndr->depth++;
19401                         if (r->info0) {
19402                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
19403                         }
19404                         ndr->depth--;
19405                 break;
19406
19407                 default:
19408                         ndr_print_bad_level(ndr, name, level);
19409         }
19410 }
19411
19412 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19413 {
19414         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19415         return NDR_ERR_SUCCESS;
19416 }
19417
19418 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19419 {
19420         uint32_t v;
19421         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19422         *r = v;
19423         return NDR_ERR_SUCCESS;
19424 }
19425
19426 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19427 {
19428         ndr_print_uint32(ndr, name, r);
19429         ndr->depth++;
19430         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
19431         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19432         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19433         ndr->depth--;
19434 }
19435
19436 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19437 {
19438         if (ndr_flags & NDR_SCALARS) {
19439                 NDR_CHECK(ndr_push_align(ndr, 5));
19440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19442                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19444                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19445                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19446                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19447                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19448         }
19449         if (ndr_flags & NDR_BUFFERS) {
19450                 if (r->client) {
19451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19454                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19455                 }
19456                 if (r->user) {
19457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19461                 }
19462         }
19463         return NDR_ERR_SUCCESS;
19464 }
19465
19466 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19467 {
19468         uint32_t _ptr_client;
19469         TALLOC_CTX *_mem_save_client_0;
19470         uint32_t _ptr_user;
19471         TALLOC_CTX *_mem_save_user_0;
19472         if (ndr_flags & NDR_SCALARS) {
19473                 NDR_CHECK(ndr_pull_align(ndr, 5));
19474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19476                 if (_ptr_client) {
19477                         NDR_PULL_ALLOC(ndr, r->client);
19478                 } else {
19479                         r->client = NULL;
19480                 }
19481                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19482                 if (_ptr_user) {
19483                         NDR_PULL_ALLOC(ndr, r->user);
19484                 } else {
19485                         r->user = NULL;
19486                 }
19487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19488                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19489                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19490                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19491                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19492         }
19493         if (ndr_flags & NDR_BUFFERS) {
19494                 if (r->client) {
19495                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19496                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19499                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19500                                 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));
19501                         }
19502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19505                 }
19506                 if (r->user) {
19507                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19508                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19511                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19512                                 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));
19513                         }
19514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19517                 }
19518         }
19519         return NDR_ERR_SUCCESS;
19520 }
19521
19522 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19523 {
19524         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19525         ndr->depth++;
19526         ndr_print_uint32(ndr, "size", r->size);
19527         ndr_print_ptr(ndr, "client", r->client);
19528         ndr->depth++;
19529         if (r->client) {
19530                 ndr_print_string(ndr, "client", r->client);
19531         }
19532         ndr->depth--;
19533         ndr_print_ptr(ndr, "user", r->user);
19534         ndr->depth++;
19535         if (r->user) {
19536                 ndr_print_string(ndr, "user", r->user);
19537         }
19538         ndr->depth--;
19539         ndr_print_uint32(ndr, "build", r->build);
19540         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19541         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19542         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19543         ndr->depth--;
19544 }
19545
19546 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19547 {
19548         if (ndr_flags & NDR_SCALARS) {
19549                 NDR_CHECK(ndr_push_align(ndr, 4));
19550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19551                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19552         }
19553         if (ndr_flags & NDR_BUFFERS) {
19554         }
19555         return NDR_ERR_SUCCESS;
19556 }
19557
19558 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19559 {
19560         if (ndr_flags & NDR_SCALARS) {
19561                 NDR_CHECK(ndr_pull_align(ndr, 4));
19562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19563                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19564         }
19565         if (ndr_flags & NDR_BUFFERS) {
19566         }
19567         return NDR_ERR_SUCCESS;
19568 }
19569
19570 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19571 {
19572         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19573         ndr->depth++;
19574         ndr_print_uint32(ndr, "not_used", r->not_used);
19575         ndr->depth--;
19576 }
19577
19578 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19579 {
19580         if (ndr_flags & NDR_SCALARS) {
19581                 NDR_CHECK(ndr_push_align(ndr, 5));
19582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19585                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19588                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19589                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19590                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19591                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19592                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19593         }
19594         if (ndr_flags & NDR_BUFFERS) {
19595                 if (r->client) {
19596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19598                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19599                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19600                 }
19601                 if (r->user) {
19602                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19605                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19606                 }
19607         }
19608         return NDR_ERR_SUCCESS;
19609 }
19610
19611 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19612 {
19613         uint32_t _ptr_client;
19614         TALLOC_CTX *_mem_save_client_0;
19615         uint32_t _ptr_user;
19616         TALLOC_CTX *_mem_save_user_0;
19617         if (ndr_flags & NDR_SCALARS) {
19618                 NDR_CHECK(ndr_pull_align(ndr, 5));
19619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19622                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19623                 if (_ptr_client) {
19624                         NDR_PULL_ALLOC(ndr, r->client);
19625                 } else {
19626                         r->client = NULL;
19627                 }
19628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19629                 if (_ptr_user) {
19630                         NDR_PULL_ALLOC(ndr, r->user);
19631                 } else {
19632                         r->user = NULL;
19633                 }
19634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19635                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19636                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19637                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19638                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19639                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19640         }
19641         if (ndr_flags & NDR_BUFFERS) {
19642                 if (r->client) {
19643                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19644                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19645                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19646                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19647                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19648                                 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));
19649                         }
19650                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19651                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19653                 }
19654                 if (r->user) {
19655                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19656                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19659                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19660                                 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));
19661                         }
19662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19665                 }
19666         }
19667         return NDR_ERR_SUCCESS;
19668 }
19669
19670 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19671 {
19672         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19673         ndr->depth++;
19674         ndr_print_uint32(ndr, "size", r->size);
19675         ndr_print_uint32(ndr, "flags", r->flags);
19676         ndr_print_uint32(ndr, "size2", r->size2);
19677         ndr_print_ptr(ndr, "client", r->client);
19678         ndr->depth++;
19679         if (r->client) {
19680                 ndr_print_string(ndr, "client", r->client);
19681         }
19682         ndr->depth--;
19683         ndr_print_ptr(ndr, "user", r->user);
19684         ndr->depth++;
19685         if (r->user) {
19686                 ndr_print_string(ndr, "user", r->user);
19687         }
19688         ndr->depth--;
19689         ndr_print_uint32(ndr, "build", r->build);
19690         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19691         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19692         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19693         ndr_print_udlong(ndr, "reserved", r->reserved);
19694         ndr->depth--;
19695 }
19696
19697 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19698 {
19699         if (ndr_flags & NDR_SCALARS) {
19700                 int level = ndr_push_get_switch_value(ndr, r);
19701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19702                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19703                 switch (level) {
19704                         case 1: {
19705                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19706                         break; }
19707
19708                         case 2: {
19709                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19710                         break; }
19711
19712                         case 3: {
19713                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19714                         break; }
19715
19716                         default:
19717                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19718                 }
19719         }
19720         if (ndr_flags & NDR_BUFFERS) {
19721                 int level = ndr_push_get_switch_value(ndr, r);
19722                 switch (level) {
19723                         case 1:
19724                                 if (r->level1) {
19725                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19726                                 }
19727                         break;
19728
19729                         case 2:
19730                                 if (r->level2) {
19731                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19732                                 }
19733                         break;
19734
19735                         case 3:
19736                                 if (r->level3) {
19737                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19738                                 }
19739                         break;
19740
19741                         default:
19742                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19743                 }
19744         }
19745         return NDR_ERR_SUCCESS;
19746 }
19747
19748 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19749 {
19750         int level;
19751         uint32_t _level;
19752         TALLOC_CTX *_mem_save_level1_0;
19753         TALLOC_CTX *_mem_save_level2_0;
19754         TALLOC_CTX *_mem_save_level3_0;
19755         level = ndr_pull_get_switch_value(ndr, r);
19756         if (ndr_flags & NDR_SCALARS) {
19757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19758                 if (_level != level) {
19759                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19760                 }
19761                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19762                 switch (level) {
19763                         case 1: {
19764                                 uint32_t _ptr_level1;
19765                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19766                                 if (_ptr_level1) {
19767                                         NDR_PULL_ALLOC(ndr, r->level1);
19768                                 } else {
19769                                         r->level1 = NULL;
19770                                 }
19771                         break; }
19772
19773                         case 2: {
19774                                 uint32_t _ptr_level2;
19775                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19776                                 if (_ptr_level2) {
19777                                         NDR_PULL_ALLOC(ndr, r->level2);
19778                                 } else {
19779                                         r->level2 = NULL;
19780                                 }
19781                         break; }
19782
19783                         case 3: {
19784                                 uint32_t _ptr_level3;
19785                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19786                                 if (_ptr_level3) {
19787                                         NDR_PULL_ALLOC(ndr, r->level3);
19788                                 } else {
19789                                         r->level3 = NULL;
19790                                 }
19791                         break; }
19792
19793                         default:
19794                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19795                 }
19796         }
19797         if (ndr_flags & NDR_BUFFERS) {
19798                 switch (level) {
19799                         case 1:
19800                                 if (r->level1) {
19801                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19802                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19803                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19804                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19805                                 }
19806                         break;
19807
19808                         case 2:
19809                                 if (r->level2) {
19810                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19811                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19812                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19813                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19814                                 }
19815                         break;
19816
19817                         case 3:
19818                                 if (r->level3) {
19819                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19820                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19821                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19822                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19823                                 }
19824                         break;
19825
19826                         default:
19827                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19828                 }
19829         }
19830         return NDR_ERR_SUCCESS;
19831 }
19832
19833 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19834 {
19835         int level;
19836         level = ndr_print_get_switch_value(ndr, r);
19837         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19838         switch (level) {
19839                 case 1:
19840                         ndr_print_ptr(ndr, "level1", r->level1);
19841                         ndr->depth++;
19842                         if (r->level1) {
19843                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19844                         }
19845                         ndr->depth--;
19846                 break;
19847
19848                 case 2:
19849                         ndr_print_ptr(ndr, "level2", r->level2);
19850                         ndr->depth++;
19851                         if (r->level2) {
19852                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19853                         }
19854                         ndr->depth--;
19855                 break;
19856
19857                 case 3:
19858                         ndr_print_ptr(ndr, "level3", r->level3);
19859                         ndr->depth++;
19860                         if (r->level3) {
19861                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19862                         }
19863                         ndr->depth--;
19864                 break;
19865
19866                 default:
19867                         ndr_print_bad_level(ndr, name, level);
19868         }
19869 }
19870
19871 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19872 {
19873         if (ndr_flags & NDR_SCALARS) {
19874                 NDR_CHECK(ndr_push_align(ndr, 5));
19875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19876                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19877                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19878                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19879         }
19880         if (ndr_flags & NDR_BUFFERS) {
19881                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19882         }
19883         return NDR_ERR_SUCCESS;
19884 }
19885
19886 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19887 {
19888         if (ndr_flags & NDR_SCALARS) {
19889                 NDR_CHECK(ndr_pull_align(ndr, 5));
19890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19891                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19892                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19893                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19894         }
19895         if (ndr_flags & NDR_BUFFERS) {
19896                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19897         }
19898         return NDR_ERR_SUCCESS;
19899 }
19900
19901 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19902 {
19903         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19904         ndr->depth++;
19905         ndr_print_uint32(ndr, "level", r->level);
19906         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19907         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19908         ndr->depth--;
19909 }
19910
19911 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19912 {
19913         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19914         return NDR_ERR_SUCCESS;
19915 }
19916
19917 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19918 {
19919         uint32_t v;
19920         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19921         *r = v;
19922         return NDR_ERR_SUCCESS;
19923 }
19924
19925 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19926 {
19927         ndr_print_uint32(ndr, name, r);
19928         ndr->depth++;
19929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19935         ndr->depth--;
19936 }
19937
19938 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19939 {
19940         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19941         if (ndr_flags & NDR_SCALARS) {
19942                 NDR_CHECK(ndr_push_align(ndr, 5));
19943                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19944                 {
19945                         uint32_t _flags_save_string = ndr->flags;
19946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19947                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19948                         ndr->flags = _flags_save_string;
19949                 }
19950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19951                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19952                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19954                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19955         }
19956         if (ndr_flags & NDR_BUFFERS) {
19957                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19958                 {
19959                         uint32_t _flags_save_string = ndr->flags;
19960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19961                         if (r->value_name) {
19962                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value_name));
19963                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19964                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value_name));
19965                         }
19966                         ndr->flags = _flags_save_string;
19967                 }
19968                 if (r->data) {
19969                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data));
19970                         {
19971                                 struct ndr_push *_ndr_data;
19972                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19973                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19974                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19975                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19976                         }
19977                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data));
19978                 }
19979         }
19980         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19981         return NDR_ERR_SUCCESS;
19982 }
19983
19984 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19985 {
19986         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19987         uint32_t _ptr_value_name;
19988         TALLOC_CTX *_mem_save_value_name_0;
19989         uint32_t _ptr_data;
19990         TALLOC_CTX *_mem_save_data_0;
19991         if (ndr_flags & NDR_SCALARS) {
19992                 NDR_CHECK(ndr_pull_align(ndr, 5));
19993                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19994                 {
19995                         uint32_t _flags_save_string = ndr->flags;
19996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19997                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19998                         if (_ptr_value_name) {
19999                                 NDR_PULL_ALLOC(ndr, r->value_name);
20000                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
20001                         } else {
20002                                 r->value_name = NULL;
20003                         }
20004                         ndr->flags = _flags_save_string;
20005                 }
20006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
20007                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
20008                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
20009                 if (_ptr_data) {
20010                         NDR_PULL_ALLOC(ndr, r->data);
20011                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
20012                 } else {
20013                         r->data = NULL;
20014                 }
20015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
20016                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
20017         }
20018         if (ndr_flags & NDR_BUFFERS) {
20019                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
20020                 {
20021                         uint32_t _flags_save_string = ndr->flags;
20022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20023                         if (r->value_name) {
20024                                 uint32_t _relative_save_offset;
20025                                 _relative_save_offset = ndr->offset;
20026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
20027                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
20028                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
20029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
20030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
20031                                 if (ndr->offset > ndr->relative_highest_offset) {
20032                                         ndr->relative_highest_offset = ndr->offset;
20033                                 }
20034                                 ndr->offset = _relative_save_offset;
20035                         }
20036                         ndr->flags = _flags_save_string;
20037                 }
20038                 if (r->data) {
20039                         uint32_t _relative_save_offset;
20040                         _relative_save_offset = ndr->offset;
20041                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
20042                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
20043                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
20044                         {
20045                                 struct ndr_pull *_ndr_data;
20046                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
20047                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
20048                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
20049                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
20050                         }
20051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
20052                         if (ndr->offset > ndr->relative_highest_offset) {
20053                                 ndr->relative_highest_offset = ndr->offset;
20054                         }
20055                         ndr->offset = _relative_save_offset;
20056                 }
20057         }
20058         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
20059         return NDR_ERR_SUCCESS;
20060 }
20061
20062 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
20063 {
20064         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
20065         ndr->depth++;
20066         ndr_print_ptr(ndr, "value_name", r->value_name);
20067         ndr->depth++;
20068         if (r->value_name) {
20069                 ndr_print_string(ndr, "value_name", r->value_name);
20070         }
20071         ndr->depth--;
20072         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
20073         ndr_print_winreg_Type(ndr, "type", r->type);
20074         ndr_print_ptr(ndr, "data", r->data);
20075         ndr->depth++;
20076         if (r->data) {
20077                 ndr_print_set_switch_value(ndr, r->data, r->type);
20078                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
20079         }
20080         ndr->depth--;
20081         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);
20082         ndr->depth--;
20083 }
20084
20085 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
20086 {
20087         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
20088 }
20089
20090 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
20091 {
20092         if (ndr_flags & NDR_SCALARS) {
20093                 int level = ndr_push_get_switch_value(ndr, r);
20094                 NDR_CHECK(ndr_push_union_align(ndr, 4));
20095                 switch (level) {
20096                         case 0: {
20097                         break; }
20098
20099                         case 1: {
20100                         break; }
20101
20102                         default: {
20103                                 {
20104                                         uint32_t _flags_save_string_array = ndr->flags;
20105                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20106                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
20107                                         ndr->flags = _flags_save_string_array;
20108                                 }
20109                         break; }
20110
20111                 }
20112         }
20113         if (ndr_flags & NDR_BUFFERS) {
20114                 int level = ndr_push_get_switch_value(ndr, r);
20115                 switch (level) {
20116                         case 0:
20117                         break;
20118
20119                         case 1:
20120                         break;
20121
20122                         default:
20123                         break;
20124
20125                 }
20126         }
20127         return NDR_ERR_SUCCESS;
20128 }
20129
20130 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
20131 {
20132         int level;
20133         level = ndr_pull_get_switch_value(ndr, r);
20134         if (ndr_flags & NDR_SCALARS) {
20135                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
20136                 switch (level) {
20137                         case 0: {
20138                         break; }
20139
20140                         case 1: {
20141                         break; }
20142
20143                         default: {
20144                                 {
20145                                         uint32_t _flags_save_string_array = ndr->flags;
20146                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20147                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
20148                                         ndr->flags = _flags_save_string_array;
20149                                 }
20150                         break; }
20151
20152                 }
20153         }
20154         if (ndr_flags & NDR_BUFFERS) {
20155                 switch (level) {
20156                         case 0:
20157                         break;
20158
20159                         case 1:
20160                         break;
20161
20162                         default:
20163                         break;
20164
20165                 }
20166         }
20167         return NDR_ERR_SUCCESS;
20168 }
20169
20170 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
20171 {
20172         int level;
20173         level = ndr_print_get_switch_value(ndr, r);
20174         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
20175         switch (level) {
20176                 case 0:
20177                 break;
20178
20179                 case 1:
20180                 break;
20181
20182                 default:
20183                         ndr_print_string_array(ndr, "string_array", r->string_array);
20184                 break;
20185
20186         }
20187 }
20188
20189 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20190 {
20191         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20192         return NDR_ERR_SUCCESS;
20193 }
20194
20195 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20196 {
20197         uint32_t v;
20198         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20199         *r = v;
20200         return NDR_ERR_SUCCESS;
20201 }
20202
20203 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20204 {
20205         ndr_print_uint32(ndr, name, r);
20206         ndr->depth++;
20207         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
20208         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
20209         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
20210         ndr->depth--;
20211 }
20212
20213 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
20214 {
20215         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
20216         return NDR_ERR_SUCCESS;
20217 }
20218
20219 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
20220 {
20221         uint32_t v;
20222         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
20223         *r = v;
20224         return NDR_ERR_SUCCESS;
20225 }
20226
20227 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
20228 {
20229         const char *val = NULL;
20230
20231         switch (r) {
20232                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
20233                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
20234         }
20235         ndr_print_enum(ndr, name, "ENUM", val, r);
20236 }
20237
20238 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
20239 {
20240         if (ndr_flags & NDR_SCALARS) {
20241                 NDR_CHECK(ndr_push_align(ndr, 4));
20242                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
20244                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20247                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20248                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20250                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20251                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20252                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20253                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20257                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20258         }
20259         if (ndr_flags & NDR_BUFFERS) {
20260         }
20261         return NDR_ERR_SUCCESS;
20262 }
20263
20264 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
20265 {
20266         if (ndr_flags & NDR_SCALARS) {
20267                 NDR_CHECK(ndr_pull_align(ndr, 4));
20268                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20270                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20273                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20274                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20276                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20277                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20278                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20279                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20283                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20284         }
20285         if (ndr_flags & NDR_BUFFERS) {
20286         }
20287         return NDR_ERR_SUCCESS;
20288 }
20289
20290 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
20291 {
20292         ndr_print_struct(ndr, name, "spoolss_PortData1");
20293         ndr->depth++;
20294         ndr_print_string(ndr, "portname", r->portname);
20295         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
20296         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20297         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20298         ndr_print_uint32(ndr, "reserved", r->reserved);
20299         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20300         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20301         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20302         ndr_print_string(ndr, "queue", r->queue);
20303         ndr_print_string(ndr, "ip_address", r->ip_address);
20304         ndr_print_string(ndr, "hardware_address", r->hardware_address);
20305         ndr_print_string(ndr, "device_type", r->device_type);
20306         ndr_print_uint32(ndr, "port_number", r->port_number);
20307         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20308         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20309         ndr->depth--;
20310 }
20311
20312 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
20313 {
20314         if (ndr_flags & NDR_SCALARS) {
20315                 NDR_CHECK(ndr_push_align(ndr, 4));
20316                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
20318                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20321                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20322                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20324                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20325                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
20330                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20331         }
20332         if (ndr_flags & NDR_BUFFERS) {
20333         }
20334         return NDR_ERR_SUCCESS;
20335 }
20336
20337 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
20338 {
20339         if (ndr_flags & NDR_SCALARS) {
20340                 NDR_CHECK(ndr_pull_align(ndr, 4));
20341                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20343                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20346                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20347                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20349                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20350                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
20355                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20356         }
20357         if (ndr_flags & NDR_BUFFERS) {
20358         }
20359         return NDR_ERR_SUCCESS;
20360 }
20361
20362 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
20363 {
20364         ndr_print_struct(ndr, name, "spoolss_PortData2");
20365         ndr->depth++;
20366         ndr_print_string(ndr, "portname", r->portname);
20367         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
20368         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20369         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20370         ndr_print_uint32(ndr, "reserved", r->reserved);
20371         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20372         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20373         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20374         ndr_print_string(ndr, "queue", r->queue);
20375         ndr_print_string(ndr, "device_type", r->device_type);
20376         ndr_print_uint32(ndr, "port_number", r->port_number);
20377         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20378         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20379         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
20380         ndr->depth--;
20381 }
20382
20383 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
20384 {
20385         if (ndr_flags & NDR_SCALARS) {
20386                 NDR_CHECK(ndr_push_align(ndr, 4));
20387                 {
20388                         uint32_t _flags_save_string = ndr->flags;
20389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20390                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
20391                         ndr->flags = _flags_save_string;
20392                 }
20393                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20394         }
20395         if (ndr_flags & NDR_BUFFERS) {
20396         }
20397         return NDR_ERR_SUCCESS;
20398 }
20399
20400 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
20401 {
20402         if (ndr_flags & NDR_SCALARS) {
20403                 NDR_CHECK(ndr_pull_align(ndr, 4));
20404                 {
20405                         uint32_t _flags_save_string = ndr->flags;
20406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20407                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
20408                         ndr->flags = _flags_save_string;
20409                 }
20410                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20411         }
20412         if (ndr_flags & NDR_BUFFERS) {
20413         }
20414         return NDR_ERR_SUCCESS;
20415 }
20416
20417 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
20418 {
20419         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
20420         ndr->depth++;
20421         ndr_print_string(ndr, "dll_name", r->dll_name);
20422         ndr->depth--;
20423 }
20424
20425 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20426 {
20427         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20428         return NDR_ERR_SUCCESS;
20429 }
20430
20431 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20432 {
20433         uint32_t v;
20434         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20435         *r = v;
20436         return NDR_ERR_SUCCESS;
20437 }
20438
20439 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20440 {
20441         ndr_print_uint32(ndr, name, r);
20442         ndr->depth++;
20443         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20444         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20445         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20446         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20451         ndr->depth--;
20452 }
20453
20454 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20455 {
20456         if (ndr_flags & NDR_SCALARS) {
20457                 NDR_CHECK(ndr_push_align(ndr, 8));
20458                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20459                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20460                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20461                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20462                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20463         }
20464         if (ndr_flags & NDR_BUFFERS) {
20465         }
20466         return NDR_ERR_SUCCESS;
20467 }
20468
20469 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20470 {
20471         if (ndr_flags & NDR_SCALARS) {
20472                 NDR_CHECK(ndr_pull_align(ndr, 8));
20473                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20474                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20475                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20476                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
20477                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20478         }
20479         if (ndr_flags & NDR_BUFFERS) {
20480         }
20481         return NDR_ERR_SUCCESS;
20482 }
20483
20484 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20485 {
20486         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20487         ndr->depth++;
20488         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20489         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20490         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20491         ndr_print_string(ndr, "formname", r->formname);
20492         ndr->depth--;
20493 }
20494
20495 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20496 {
20497         if (flags & NDR_IN) {
20498                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20499                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20500                 if (r->in.server) {
20501                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20502                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20504                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20505                 }
20506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20508                 if (r->in.buffer) {
20509                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20510                 }
20511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20512         }
20513         if (flags & NDR_OUT) {
20514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20515                 if (r->out.info) {
20516                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20517                 }
20518                 if (r->out.needed == NULL) {
20519                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20520                 }
20521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20522                 if (r->out.count == NULL) {
20523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20524                 }
20525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20526                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20527         }
20528         return NDR_ERR_SUCCESS;
20529 }
20530
20531 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20532 {
20533         uint32_t _ptr_server;
20534         uint32_t _ptr_buffer;
20535         uint32_t _ptr_info;
20536         TALLOC_CTX *_mem_save_server_0;
20537         TALLOC_CTX *_mem_save_buffer_0;
20538         TALLOC_CTX *_mem_save_info_0;
20539         TALLOC_CTX *_mem_save_needed_0;
20540         TALLOC_CTX *_mem_save_count_0;
20541         if (flags & NDR_IN) {
20542                 ZERO_STRUCT(r->out);
20543
20544                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20546                 if (_ptr_server) {
20547                         NDR_PULL_ALLOC(ndr, r->in.server);
20548                 } else {
20549                         r->in.server = NULL;
20550                 }
20551                 if (r->in.server) {
20552                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20553                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20555                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20556                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20557                                 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));
20558                         }
20559                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20560                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20562                 }
20563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20565                 if (_ptr_buffer) {
20566                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20567                 } else {
20568                         r->in.buffer = NULL;
20569                 }
20570                 if (r->in.buffer) {
20571                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20572                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20573                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20575                 }
20576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20577                 NDR_PULL_ALLOC(ndr, r->out.needed);
20578                 ZERO_STRUCTP(r->out.needed);
20579                 NDR_PULL_ALLOC(ndr, r->out.count);
20580                 ZERO_STRUCTP(r->out.count);
20581         }
20582         if (flags & NDR_OUT) {
20583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20584                 if (_ptr_info) {
20585                         NDR_PULL_ALLOC(ndr, r->out.info);
20586                 } else {
20587                         r->out.info = NULL;
20588                 }
20589                 if (r->out.info) {
20590                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20591                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20592                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20594                 }
20595                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20596                         NDR_PULL_ALLOC(ndr, r->out.needed);
20597                 }
20598                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20599                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20602                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20603                         NDR_PULL_ALLOC(ndr, r->out.count);
20604                 }
20605                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20606                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20608                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20609                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20610         }
20611         return NDR_ERR_SUCCESS;
20612 }
20613
20614 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20615 {
20616         uint32_t cntr_info_0;
20617         if (flags & NDR_IN) {
20618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20620         }
20621         if (flags & NDR_OUT) {
20622                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20623                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20624                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20625                 }
20626                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20627                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20628                 }
20629         }
20630         return NDR_ERR_SUCCESS;
20631 }
20632
20633 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20634 {
20635         uint32_t cntr_info_0;
20636         TALLOC_CTX *_mem_save_info_0;
20637         if (flags & NDR_IN) {
20638                 ZERO_STRUCT(r->out);
20639
20640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20642         }
20643         if (flags & NDR_OUT) {
20644                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20645                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20646                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20647                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20648                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20649                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20650                 }
20651                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20652                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20653                 }
20654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20655         }
20656         return NDR_ERR_SUCCESS;
20657 }
20658
20659 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20660 {
20661         uint32_t cntr_info_2;
20662         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20663         ndr->depth++;
20664         if (flags & NDR_SET_VALUES) {
20665                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20666         }
20667         if (flags & NDR_IN) {
20668                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20669                 ndr->depth++;
20670                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20671                 ndr_print_ptr(ndr, "server", r->in.server);
20672                 ndr->depth++;
20673                 if (r->in.server) {
20674                         ndr_print_string(ndr, "server", r->in.server);
20675                 }
20676                 ndr->depth--;
20677                 ndr_print_uint32(ndr, "level", r->in.level);
20678                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20679                 ndr->depth++;
20680                 if (r->in.buffer) {
20681                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20682                 }
20683                 ndr->depth--;
20684                 ndr_print_uint32(ndr, "offered", r->in.offered);
20685                 ndr->depth--;
20686         }
20687         if (flags & NDR_OUT) {
20688                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20689                 ndr->depth++;
20690                 ndr_print_ptr(ndr, "count", r->out.count);
20691                 ndr->depth++;
20692                 ndr_print_uint32(ndr, "count", *r->out.count);
20693                 ndr->depth--;
20694                 ndr_print_ptr(ndr, "info", r->out.info);
20695                 ndr->depth++;
20696                 ndr_print_ptr(ndr, "info", *r->out.info);
20697                 ndr->depth++;
20698                 if (*r->out.info) {
20699                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20700                         ndr->depth++;
20701                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20702                                 char *idx_2=NULL;
20703                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20704                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20705                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20706                                         free(idx_2);
20707                                 }
20708                         }
20709                         ndr->depth--;
20710                 }
20711                 ndr->depth--;
20712                 ndr->depth--;
20713                 ndr_print_ptr(ndr, "needed", r->out.needed);
20714                 ndr->depth++;
20715                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20716                 ndr->depth--;
20717                 ndr_print_WERROR(ndr, "result", r->out.result);
20718                 ndr->depth--;
20719         }
20720         ndr->depth--;
20721 }
20722
20723 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20724 {
20725         if (flags & NDR_IN) {
20726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20727                 if (r->in.printername) {
20728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20732                 }
20733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20734                 if (r->in.datatype) {
20735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20737                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20739                 }
20740                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20741                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20742         }
20743         if (flags & NDR_OUT) {
20744                 if (r->out.handle == NULL) {
20745                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20746                 }
20747                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20748                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20749         }
20750         return NDR_ERR_SUCCESS;
20751 }
20752
20753 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20754 {
20755         uint32_t _ptr_printername;
20756         uint32_t _ptr_datatype;
20757         TALLOC_CTX *_mem_save_printername_0;
20758         TALLOC_CTX *_mem_save_datatype_0;
20759         TALLOC_CTX *_mem_save_handle_0;
20760         if (flags & NDR_IN) {
20761                 ZERO_STRUCT(r->out);
20762
20763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20764                 if (_ptr_printername) {
20765                         NDR_PULL_ALLOC(ndr, r->in.printername);
20766                 } else {
20767                         r->in.printername = NULL;
20768                 }
20769                 if (r->in.printername) {
20770                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20771                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20773                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20774                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20775                                 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));
20776                         }
20777                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20778                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20780                 }
20781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20782                 if (_ptr_datatype) {
20783                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20784                 } else {
20785                         r->in.datatype = NULL;
20786                 }
20787                 if (r->in.datatype) {
20788                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20789                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20792                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20793                                 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));
20794                         }
20795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20798                 }
20799                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20800                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20801                 NDR_PULL_ALLOC(ndr, r->out.handle);
20802                 ZERO_STRUCTP(r->out.handle);
20803         }
20804         if (flags & NDR_OUT) {
20805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20806                         NDR_PULL_ALLOC(ndr, r->out.handle);
20807                 }
20808                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20809                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20810                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20812                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20813         }
20814         return NDR_ERR_SUCCESS;
20815 }
20816
20817 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20818 {
20819         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20820         ndr->depth++;
20821         if (flags & NDR_SET_VALUES) {
20822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20823         }
20824         if (flags & NDR_IN) {
20825                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20826                 ndr->depth++;
20827                 ndr_print_ptr(ndr, "printername", r->in.printername);
20828                 ndr->depth++;
20829                 if (r->in.printername) {
20830                         ndr_print_string(ndr, "printername", r->in.printername);
20831                 }
20832                 ndr->depth--;
20833                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20834                 ndr->depth++;
20835                 if (r->in.datatype) {
20836                         ndr_print_string(ndr, "datatype", r->in.datatype);
20837                 }
20838                 ndr->depth--;
20839                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20840                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20841                 ndr->depth--;
20842         }
20843         if (flags & NDR_OUT) {
20844                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20845                 ndr->depth++;
20846                 ndr_print_ptr(ndr, "handle", r->out.handle);
20847                 ndr->depth++;
20848                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20849                 ndr->depth--;
20850                 ndr_print_WERROR(ndr, "result", r->out.result);
20851                 ndr->depth--;
20852         }
20853         ndr->depth--;
20854 }
20855
20856 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20857 {
20858         if (flags & NDR_IN) {
20859                 if (r->in.handle == NULL) {
20860                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20861                 }
20862                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20865                 if (r->in.ctr) {
20866                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20867                 }
20868                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20869         }
20870         if (flags & NDR_OUT) {
20871                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20872         }
20873         return NDR_ERR_SUCCESS;
20874 }
20875
20876 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20877 {
20878         uint32_t _ptr_ctr;
20879         TALLOC_CTX *_mem_save_handle_0;
20880         TALLOC_CTX *_mem_save_ctr_0;
20881         if (flags & NDR_IN) {
20882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20883                         NDR_PULL_ALLOC(ndr, r->in.handle);
20884                 }
20885                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20886                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20887                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20891                 if (_ptr_ctr) {
20892                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20893                 } else {
20894                         r->in.ctr = NULL;
20895                 }
20896                 if (r->in.ctr) {
20897                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20898                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20899                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20901                 }
20902                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20903         }
20904         if (flags & NDR_OUT) {
20905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20906         }
20907         return NDR_ERR_SUCCESS;
20908 }
20909
20910 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20911 {
20912         ndr_print_struct(ndr, name, "spoolss_SetJob");
20913         ndr->depth++;
20914         if (flags & NDR_SET_VALUES) {
20915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20916         }
20917         if (flags & NDR_IN) {
20918                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20919                 ndr->depth++;
20920                 ndr_print_ptr(ndr, "handle", r->in.handle);
20921                 ndr->depth++;
20922                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20923                 ndr->depth--;
20924                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20925                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20926                 ndr->depth++;
20927                 if (r->in.ctr) {
20928                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20929                 }
20930                 ndr->depth--;
20931                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20932                 ndr->depth--;
20933         }
20934         if (flags & NDR_OUT) {
20935                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20936                 ndr->depth++;
20937                 ndr_print_WERROR(ndr, "result", r->out.result);
20938                 ndr->depth--;
20939         }
20940         ndr->depth--;
20941 }
20942
20943 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20944 {
20945         if (flags & NDR_IN) {
20946                 if (r->in.handle == NULL) {
20947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20948                 }
20949                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20952                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20953                 if (r->in.buffer) {
20954                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20955                 }
20956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20957         }
20958         if (flags & NDR_OUT) {
20959                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20960                 if (r->out.info) {
20961                         {
20962                                 struct ndr_push *_ndr_info;
20963                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20964                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20965                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20966                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20967                         }
20968                 }
20969                 if (r->out.needed == NULL) {
20970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20971                 }
20972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20973                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20974         }
20975         return NDR_ERR_SUCCESS;
20976 }
20977
20978 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20979 {
20980         uint32_t _ptr_buffer;
20981         uint32_t _ptr_info;
20982         TALLOC_CTX *_mem_save_handle_0;
20983         TALLOC_CTX *_mem_save_buffer_0;
20984         TALLOC_CTX *_mem_save_info_0;
20985         TALLOC_CTX *_mem_save_needed_0;
20986         if (flags & NDR_IN) {
20987                 ZERO_STRUCT(r->out);
20988
20989                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20990                         NDR_PULL_ALLOC(ndr, r->in.handle);
20991                 }
20992                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20993                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20994                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20995                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20997                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20999                 if (_ptr_buffer) {
21000                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21001                 } else {
21002                         r->in.buffer = NULL;
21003                 }
21004                 if (r->in.buffer) {
21005                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21006                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21007                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21009                 }
21010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21011                 NDR_PULL_ALLOC(ndr, r->out.needed);
21012                 ZERO_STRUCTP(r->out.needed);
21013         }
21014         if (flags & NDR_OUT) {
21015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21016                 if (_ptr_info) {
21017                         NDR_PULL_ALLOC(ndr, r->out.info);
21018                 } else {
21019                         r->out.info = NULL;
21020                 }
21021                 if (r->out.info) {
21022                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21023                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21024                         {
21025                                 struct ndr_pull *_ndr_info;
21026                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21027                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21028                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21029                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21030                         }
21031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21032                 }
21033                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21034                         NDR_PULL_ALLOC(ndr, r->out.needed);
21035                 }
21036                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21037                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21039                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21040                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21041         }
21042         return NDR_ERR_SUCCESS;
21043 }
21044
21045 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
21046 {
21047         ndr_print_struct(ndr, name, "spoolss_GetJob");
21048         ndr->depth++;
21049         if (flags & NDR_SET_VALUES) {
21050                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21051         }
21052         if (flags & NDR_IN) {
21053                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
21054                 ndr->depth++;
21055                 ndr_print_ptr(ndr, "handle", r->in.handle);
21056                 ndr->depth++;
21057                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21058                 ndr->depth--;
21059                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
21060                 ndr_print_uint32(ndr, "level", r->in.level);
21061                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21062                 ndr->depth++;
21063                 if (r->in.buffer) {
21064                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21065                 }
21066                 ndr->depth--;
21067                 ndr_print_uint32(ndr, "offered", r->in.offered);
21068                 ndr->depth--;
21069         }
21070         if (flags & NDR_OUT) {
21071                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
21072                 ndr->depth++;
21073                 ndr_print_ptr(ndr, "info", r->out.info);
21074                 ndr->depth++;
21075                 if (r->out.info) {
21076                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21077                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
21078                 }
21079                 ndr->depth--;
21080                 ndr_print_ptr(ndr, "needed", r->out.needed);
21081                 ndr->depth++;
21082                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21083                 ndr->depth--;
21084                 ndr_print_WERROR(ndr, "result", r->out.result);
21085                 ndr->depth--;
21086         }
21087         ndr->depth--;
21088 }
21089
21090 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
21091 {
21092         if (flags & NDR_IN) {
21093                 if (r->in.handle == NULL) {
21094                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21095                 }
21096                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
21098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
21099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21101                 if (r->in.buffer) {
21102                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21103                 }
21104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21105         }
21106         if (flags & NDR_OUT) {
21107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21108                 if (r->out.info) {
21109                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21110                 }
21111                 if (r->out.needed == NULL) {
21112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21113                 }
21114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21115                 if (r->out.count == NULL) {
21116                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21117                 }
21118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21120         }
21121         return NDR_ERR_SUCCESS;
21122 }
21123
21124 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
21125 {
21126         uint32_t _ptr_buffer;
21127         uint32_t _ptr_info;
21128         TALLOC_CTX *_mem_save_handle_0;
21129         TALLOC_CTX *_mem_save_buffer_0;
21130         TALLOC_CTX *_mem_save_info_0;
21131         TALLOC_CTX *_mem_save_needed_0;
21132         TALLOC_CTX *_mem_save_count_0;
21133         if (flags & NDR_IN) {
21134                 ZERO_STRUCT(r->out);
21135
21136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21137                         NDR_PULL_ALLOC(ndr, r->in.handle);
21138                 }
21139                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21140                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21141                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
21144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
21145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21147                 if (_ptr_buffer) {
21148                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21149                 } else {
21150                         r->in.buffer = NULL;
21151                 }
21152                 if (r->in.buffer) {
21153                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21154                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21155                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21157                 }
21158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21159                 NDR_PULL_ALLOC(ndr, r->out.needed);
21160                 ZERO_STRUCTP(r->out.needed);
21161                 NDR_PULL_ALLOC(ndr, r->out.count);
21162                 ZERO_STRUCTP(r->out.count);
21163         }
21164         if (flags & NDR_OUT) {
21165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21166                 if (_ptr_info) {
21167                         NDR_PULL_ALLOC(ndr, r->out.info);
21168                 } else {
21169                         r->out.info = NULL;
21170                 }
21171                 if (r->out.info) {
21172                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21173                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21174                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21176                 }
21177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21178                         NDR_PULL_ALLOC(ndr, r->out.needed);
21179                 }
21180                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21181                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21183                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21185                         NDR_PULL_ALLOC(ndr, r->out.count);
21186                 }
21187                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21188                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21191                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21192         }
21193         return NDR_ERR_SUCCESS;
21194 }
21195
21196 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
21197 {
21198         uint32_t cntr_info_0;
21199         if (flags & NDR_IN) {
21200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21202         }
21203         if (flags & NDR_OUT) {
21204                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21205                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21206                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21207                 }
21208                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21209                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21210                 }
21211         }
21212         return NDR_ERR_SUCCESS;
21213 }
21214
21215 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
21216 {
21217         uint32_t cntr_info_0;
21218         TALLOC_CTX *_mem_save_info_0;
21219         if (flags & NDR_IN) {
21220                 ZERO_STRUCT(r->out);
21221
21222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21224         }
21225         if (flags & NDR_OUT) {
21226                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21227                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21228                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21229                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21230                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21231                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21232                 }
21233                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21234                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21235                 }
21236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21237         }
21238         return NDR_ERR_SUCCESS;
21239 }
21240
21241 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
21242 {
21243         uint32_t cntr_info_2;
21244         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
21245         ndr->depth++;
21246         if (flags & NDR_SET_VALUES) {
21247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21248         }
21249         if (flags & NDR_IN) {
21250                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
21251                 ndr->depth++;
21252                 ndr_print_ptr(ndr, "handle", r->in.handle);
21253                 ndr->depth++;
21254                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21255                 ndr->depth--;
21256                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
21257                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
21258                 ndr_print_uint32(ndr, "level", r->in.level);
21259                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21260                 ndr->depth++;
21261                 if (r->in.buffer) {
21262                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21263                 }
21264                 ndr->depth--;
21265                 ndr_print_uint32(ndr, "offered", r->in.offered);
21266                 ndr->depth--;
21267         }
21268         if (flags & NDR_OUT) {
21269                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
21270                 ndr->depth++;
21271                 ndr_print_ptr(ndr, "count", r->out.count);
21272                 ndr->depth++;
21273                 ndr_print_uint32(ndr, "count", *r->out.count);
21274                 ndr->depth--;
21275                 ndr_print_ptr(ndr, "info", r->out.info);
21276                 ndr->depth++;
21277                 ndr_print_ptr(ndr, "info", *r->out.info);
21278                 ndr->depth++;
21279                 if (*r->out.info) {
21280                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21281                         ndr->depth++;
21282                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21283                                 char *idx_2=NULL;
21284                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21285                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21286                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21287                                         free(idx_2);
21288                                 }
21289                         }
21290                         ndr->depth--;
21291                 }
21292                 ndr->depth--;
21293                 ndr->depth--;
21294                 ndr_print_ptr(ndr, "needed", r->out.needed);
21295                 ndr->depth++;
21296                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21297                 ndr->depth--;
21298                 ndr_print_WERROR(ndr, "result", r->out.result);
21299                 ndr->depth--;
21300         }
21301         ndr->depth--;
21302 }
21303
21304 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
21305 {
21306         if (flags & NDR_IN) {
21307                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21308                 if (r->in.server) {
21309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21312                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21313                 }
21314                 if (r->in.info_ctr == NULL) {
21315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21316                 }
21317                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21318                 if (r->in.devmode_ctr == NULL) {
21319                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21320                 }
21321                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21322                 if (r->in.secdesc_ctr == NULL) {
21323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21324                 }
21325                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21326         }
21327         if (flags & NDR_OUT) {
21328                 if (r->out.handle == NULL) {
21329                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21330                 }
21331                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21332                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21333         }
21334         return NDR_ERR_SUCCESS;
21335 }
21336
21337 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
21338 {
21339         uint32_t _ptr_server;
21340         TALLOC_CTX *_mem_save_server_0;
21341         TALLOC_CTX *_mem_save_info_ctr_0;
21342         TALLOC_CTX *_mem_save_devmode_ctr_0;
21343         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21344         TALLOC_CTX *_mem_save_handle_0;
21345         if (flags & NDR_IN) {
21346                 ZERO_STRUCT(r->out);
21347
21348                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21349                 if (_ptr_server) {
21350                         NDR_PULL_ALLOC(ndr, r->in.server);
21351                 } else {
21352                         r->in.server = NULL;
21353                 }
21354                 if (r->in.server) {
21355                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21356                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21357                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21358                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21359                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21360                                 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));
21361                         }
21362                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21363                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21365                 }
21366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21367                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21368                 }
21369                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21370                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21371                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21372                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21374                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21375                 }
21376                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21377                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21378                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21379                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21381                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21382                 }
21383                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21384                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21385                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21387                 NDR_PULL_ALLOC(ndr, r->out.handle);
21388                 ZERO_STRUCTP(r->out.handle);
21389         }
21390         if (flags & NDR_OUT) {
21391                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21392                         NDR_PULL_ALLOC(ndr, r->out.handle);
21393                 }
21394                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21395                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21396                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21397                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21398                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21399         }
21400         return NDR_ERR_SUCCESS;
21401 }
21402
21403 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
21404 {
21405         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
21406         ndr->depth++;
21407         if (flags & NDR_SET_VALUES) {
21408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21409         }
21410         if (flags & NDR_IN) {
21411                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
21412                 ndr->depth++;
21413                 ndr_print_ptr(ndr, "server", r->in.server);
21414                 ndr->depth++;
21415                 if (r->in.server) {
21416                         ndr_print_string(ndr, "server", r->in.server);
21417                 }
21418                 ndr->depth--;
21419                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21420                 ndr->depth++;
21421                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21422                 ndr->depth--;
21423                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21424                 ndr->depth++;
21425                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21426                 ndr->depth--;
21427                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21428                 ndr->depth++;
21429                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21430                 ndr->depth--;
21431                 ndr->depth--;
21432         }
21433         if (flags & NDR_OUT) {
21434                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21435                 ndr->depth++;
21436                 ndr_print_ptr(ndr, "handle", r->out.handle);
21437                 ndr->depth++;
21438                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21439                 ndr->depth--;
21440                 ndr_print_WERROR(ndr, "result", r->out.result);
21441                 ndr->depth--;
21442         }
21443         ndr->depth--;
21444 }
21445
21446 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21447 {
21448         if (flags & NDR_IN) {
21449                 if (r->in.handle == NULL) {
21450                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21451                 }
21452                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21453         }
21454         if (flags & NDR_OUT) {
21455                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21456         }
21457         return NDR_ERR_SUCCESS;
21458 }
21459
21460 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21461 {
21462         TALLOC_CTX *_mem_save_handle_0;
21463         if (flags & NDR_IN) {
21464                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21465                         NDR_PULL_ALLOC(ndr, r->in.handle);
21466                 }
21467                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21468                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21469                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21471         }
21472         if (flags & NDR_OUT) {
21473                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21474         }
21475         return NDR_ERR_SUCCESS;
21476 }
21477
21478 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21479 {
21480         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21481         ndr->depth++;
21482         if (flags & NDR_SET_VALUES) {
21483                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21484         }
21485         if (flags & NDR_IN) {
21486                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21487                 ndr->depth++;
21488                 ndr_print_ptr(ndr, "handle", r->in.handle);
21489                 ndr->depth++;
21490                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21491                 ndr->depth--;
21492                 ndr->depth--;
21493         }
21494         if (flags & NDR_OUT) {
21495                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21496                 ndr->depth++;
21497                 ndr_print_WERROR(ndr, "result", r->out.result);
21498                 ndr->depth--;
21499         }
21500         ndr->depth--;
21501 }
21502
21503 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21504 {
21505         if (flags & NDR_IN) {
21506                 if (r->in.handle == NULL) {
21507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21508                 }
21509                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21510                 if (r->in.info_ctr == NULL) {
21511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21512                 }
21513                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21514                 if (r->in.devmode_ctr == NULL) {
21515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21516                 }
21517                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21518                 if (r->in.secdesc_ctr == NULL) {
21519                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21520                 }
21521                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21522                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21523         }
21524         if (flags & NDR_OUT) {
21525                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21526         }
21527         return NDR_ERR_SUCCESS;
21528 }
21529
21530 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21531 {
21532         TALLOC_CTX *_mem_save_handle_0;
21533         TALLOC_CTX *_mem_save_info_ctr_0;
21534         TALLOC_CTX *_mem_save_devmode_ctr_0;
21535         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21536         if (flags & NDR_IN) {
21537                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21538                         NDR_PULL_ALLOC(ndr, r->in.handle);
21539                 }
21540                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21541                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21542                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21543                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21545                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21546                 }
21547                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21548                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21549                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21552                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21553                 }
21554                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21555                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21556                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21559                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21560                 }
21561                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21562                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21563                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21565                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21566         }
21567         if (flags & NDR_OUT) {
21568                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21569         }
21570         return NDR_ERR_SUCCESS;
21571 }
21572
21573 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21574 {
21575         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21576         ndr->depth++;
21577         if (flags & NDR_SET_VALUES) {
21578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21579         }
21580         if (flags & NDR_IN) {
21581                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21582                 ndr->depth++;
21583                 ndr_print_ptr(ndr, "handle", r->in.handle);
21584                 ndr->depth++;
21585                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21586                 ndr->depth--;
21587                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21588                 ndr->depth++;
21589                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21590                 ndr->depth--;
21591                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21592                 ndr->depth++;
21593                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21594                 ndr->depth--;
21595                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21596                 ndr->depth++;
21597                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21598                 ndr->depth--;
21599                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21600                 ndr->depth--;
21601         }
21602         if (flags & NDR_OUT) {
21603                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21604                 ndr->depth++;
21605                 ndr_print_WERROR(ndr, "result", r->out.result);
21606                 ndr->depth--;
21607         }
21608         ndr->depth--;
21609 }
21610
21611 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21612 {
21613         if (flags & NDR_IN) {
21614                 if (r->in.handle == NULL) {
21615                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21616                 }
21617                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21620                 if (r->in.buffer) {
21621                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21622                 }
21623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21624         }
21625         if (flags & NDR_OUT) {
21626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21627                 if (r->out.info) {
21628                         {
21629                                 struct ndr_push *_ndr_info;
21630                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21631                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21632                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21633                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21634                         }
21635                 }
21636                 if (r->out.needed == NULL) {
21637                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21638                 }
21639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21640                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21641         }
21642         return NDR_ERR_SUCCESS;
21643 }
21644
21645 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21646 {
21647         uint32_t _ptr_buffer;
21648         uint32_t _ptr_info;
21649         TALLOC_CTX *_mem_save_handle_0;
21650         TALLOC_CTX *_mem_save_buffer_0;
21651         TALLOC_CTX *_mem_save_info_0;
21652         TALLOC_CTX *_mem_save_needed_0;
21653         if (flags & NDR_IN) {
21654                 ZERO_STRUCT(r->out);
21655
21656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21657                         NDR_PULL_ALLOC(ndr, r->in.handle);
21658                 }
21659                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21661                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21665                 if (_ptr_buffer) {
21666                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21667                 } else {
21668                         r->in.buffer = NULL;
21669                 }
21670                 if (r->in.buffer) {
21671                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21672                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21673                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21675                 }
21676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21677                 NDR_PULL_ALLOC(ndr, r->out.needed);
21678                 ZERO_STRUCTP(r->out.needed);
21679         }
21680         if (flags & NDR_OUT) {
21681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21682                 if (_ptr_info) {
21683                         NDR_PULL_ALLOC(ndr, r->out.info);
21684                 } else {
21685                         r->out.info = NULL;
21686                 }
21687                 if (r->out.info) {
21688                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21689                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21690                         {
21691                                 struct ndr_pull *_ndr_info;
21692                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21693                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21694                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21695                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21696                         }
21697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21698                 }
21699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21700                         NDR_PULL_ALLOC(ndr, r->out.needed);
21701                 }
21702                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21703                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21706                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21707         }
21708         return NDR_ERR_SUCCESS;
21709 }
21710
21711 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21712 {
21713         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21714         ndr->depth++;
21715         if (flags & NDR_SET_VALUES) {
21716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21717         }
21718         if (flags & NDR_IN) {
21719                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21720                 ndr->depth++;
21721                 ndr_print_ptr(ndr, "handle", r->in.handle);
21722                 ndr->depth++;
21723                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21724                 ndr->depth--;
21725                 ndr_print_uint32(ndr, "level", r->in.level);
21726                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21727                 ndr->depth++;
21728                 if (r->in.buffer) {
21729                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21730                 }
21731                 ndr->depth--;
21732                 ndr_print_uint32(ndr, "offered", r->in.offered);
21733                 ndr->depth--;
21734         }
21735         if (flags & NDR_OUT) {
21736                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21737                 ndr->depth++;
21738                 ndr_print_ptr(ndr, "info", r->out.info);
21739                 ndr->depth++;
21740                 if (r->out.info) {
21741                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21742                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21743                 }
21744                 ndr->depth--;
21745                 ndr_print_ptr(ndr, "needed", r->out.needed);
21746                 ndr->depth++;
21747                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21748                 ndr->depth--;
21749                 ndr_print_WERROR(ndr, "result", r->out.result);
21750                 ndr->depth--;
21751         }
21752         ndr->depth--;
21753 }
21754
21755 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21756 {
21757         if (flags & NDR_IN) {
21758                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21759                 if (r->in.servername) {
21760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21761                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21764                 }
21765                 if (r->in.info_ctr == NULL) {
21766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21767                 }
21768                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21769         }
21770         if (flags & NDR_OUT) {
21771                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21772         }
21773         return NDR_ERR_SUCCESS;
21774 }
21775
21776 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21777 {
21778         uint32_t _ptr_servername;
21779         TALLOC_CTX *_mem_save_servername_0;
21780         TALLOC_CTX *_mem_save_info_ctr_0;
21781         if (flags & NDR_IN) {
21782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21783                 if (_ptr_servername) {
21784                         NDR_PULL_ALLOC(ndr, r->in.servername);
21785                 } else {
21786                         r->in.servername = NULL;
21787                 }
21788                 if (r->in.servername) {
21789                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21790                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21793                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21794                                 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));
21795                         }
21796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21799                 }
21800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21801                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21802                 }
21803                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21804                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21805                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21807         }
21808         if (flags & NDR_OUT) {
21809                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21810         }
21811         return NDR_ERR_SUCCESS;
21812 }
21813
21814 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21815 {
21816         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21817         ndr->depth++;
21818         if (flags & NDR_SET_VALUES) {
21819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21820         }
21821         if (flags & NDR_IN) {
21822                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21823                 ndr->depth++;
21824                 ndr_print_ptr(ndr, "servername", r->in.servername);
21825                 ndr->depth++;
21826                 if (r->in.servername) {
21827                         ndr_print_string(ndr, "servername", r->in.servername);
21828                 }
21829                 ndr->depth--;
21830                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21831                 ndr->depth++;
21832                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21833                 ndr->depth--;
21834                 ndr->depth--;
21835         }
21836         if (flags & NDR_OUT) {
21837                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21838                 ndr->depth++;
21839                 ndr_print_WERROR(ndr, "result", r->out.result);
21840                 ndr->depth--;
21841         }
21842         ndr->depth--;
21843 }
21844
21845 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21846 {
21847         if (flags & NDR_IN) {
21848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21849                 if (r->in.server) {
21850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21854                 }
21855                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21856                 if (r->in.environment) {
21857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21861                 }
21862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21864                 if (r->in.buffer) {
21865                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21866                 }
21867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21868         }
21869         if (flags & NDR_OUT) {
21870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21871                 if (r->out.info) {
21872                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21873                 }
21874                 if (r->out.needed == NULL) {
21875                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21876                 }
21877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21878                 if (r->out.count == NULL) {
21879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21880                 }
21881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21882                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21883         }
21884         return NDR_ERR_SUCCESS;
21885 }
21886
21887 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21888 {
21889         uint32_t _ptr_server;
21890         uint32_t _ptr_environment;
21891         uint32_t _ptr_buffer;
21892         uint32_t _ptr_info;
21893         TALLOC_CTX *_mem_save_server_0;
21894         TALLOC_CTX *_mem_save_environment_0;
21895         TALLOC_CTX *_mem_save_buffer_0;
21896         TALLOC_CTX *_mem_save_info_0;
21897         TALLOC_CTX *_mem_save_needed_0;
21898         TALLOC_CTX *_mem_save_count_0;
21899         if (flags & NDR_IN) {
21900                 ZERO_STRUCT(r->out);
21901
21902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21903                 if (_ptr_server) {
21904                         NDR_PULL_ALLOC(ndr, r->in.server);
21905                 } else {
21906                         r->in.server = NULL;
21907                 }
21908                 if (r->in.server) {
21909                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21910                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21913                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21914                                 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));
21915                         }
21916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21919                 }
21920                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21921                 if (_ptr_environment) {
21922                         NDR_PULL_ALLOC(ndr, r->in.environment);
21923                 } else {
21924                         r->in.environment = NULL;
21925                 }
21926                 if (r->in.environment) {
21927                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21928                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21929                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21930                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21931                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21932                                 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));
21933                         }
21934                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21937                 }
21938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21939                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21940                 if (_ptr_buffer) {
21941                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21942                 } else {
21943                         r->in.buffer = NULL;
21944                 }
21945                 if (r->in.buffer) {
21946                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21947                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21948                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21950                 }
21951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21952                 NDR_PULL_ALLOC(ndr, r->out.needed);
21953                 ZERO_STRUCTP(r->out.needed);
21954                 NDR_PULL_ALLOC(ndr, r->out.count);
21955                 ZERO_STRUCTP(r->out.count);
21956         }
21957         if (flags & NDR_OUT) {
21958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21959                 if (_ptr_info) {
21960                         NDR_PULL_ALLOC(ndr, r->out.info);
21961                 } else {
21962                         r->out.info = NULL;
21963                 }
21964                 if (r->out.info) {
21965                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21966                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21967                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21969                 }
21970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21971                         NDR_PULL_ALLOC(ndr, r->out.needed);
21972                 }
21973                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21974                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21977                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21978                         NDR_PULL_ALLOC(ndr, r->out.count);
21979                 }
21980                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21981                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21983                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21984                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21985         }
21986         return NDR_ERR_SUCCESS;
21987 }
21988
21989 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21990 {
21991         uint32_t cntr_info_0;
21992         if (flags & NDR_IN) {
21993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21995         }
21996         if (flags & NDR_OUT) {
21997                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21998                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21999                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22000                 }
22001                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22002                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22003                 }
22004         }
22005         return NDR_ERR_SUCCESS;
22006 }
22007
22008 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
22009 {
22010         uint32_t cntr_info_0;
22011         TALLOC_CTX *_mem_save_info_0;
22012         if (flags & NDR_IN) {
22013                 ZERO_STRUCT(r->out);
22014
22015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22017         }
22018         if (flags & NDR_OUT) {
22019                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22020                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22021                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22022                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22023                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22024                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22025                 }
22026                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22027                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22028                 }
22029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22030         }
22031         return NDR_ERR_SUCCESS;
22032 }
22033
22034 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
22035 {
22036         uint32_t cntr_info_2;
22037         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
22038         ndr->depth++;
22039         if (flags & NDR_SET_VALUES) {
22040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22041         }
22042         if (flags & NDR_IN) {
22043                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
22044                 ndr->depth++;
22045                 ndr_print_ptr(ndr, "server", r->in.server);
22046                 ndr->depth++;
22047                 if (r->in.server) {
22048                         ndr_print_string(ndr, "server", r->in.server);
22049                 }
22050                 ndr->depth--;
22051                 ndr_print_ptr(ndr, "environment", r->in.environment);
22052                 ndr->depth++;
22053                 if (r->in.environment) {
22054                         ndr_print_string(ndr, "environment", r->in.environment);
22055                 }
22056                 ndr->depth--;
22057                 ndr_print_uint32(ndr, "level", r->in.level);
22058                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22059                 ndr->depth++;
22060                 if (r->in.buffer) {
22061                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22062                 }
22063                 ndr->depth--;
22064                 ndr_print_uint32(ndr, "offered", r->in.offered);
22065                 ndr->depth--;
22066         }
22067         if (flags & NDR_OUT) {
22068                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
22069                 ndr->depth++;
22070                 ndr_print_ptr(ndr, "count", r->out.count);
22071                 ndr->depth++;
22072                 ndr_print_uint32(ndr, "count", *r->out.count);
22073                 ndr->depth--;
22074                 ndr_print_ptr(ndr, "info", r->out.info);
22075                 ndr->depth++;
22076                 ndr_print_ptr(ndr, "info", *r->out.info);
22077                 ndr->depth++;
22078                 if (*r->out.info) {
22079                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22080                         ndr->depth++;
22081                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22082                                 char *idx_2=NULL;
22083                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22084                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22085                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22086                                         free(idx_2);
22087                                 }
22088                         }
22089                         ndr->depth--;
22090                 }
22091                 ndr->depth--;
22092                 ndr->depth--;
22093                 ndr_print_ptr(ndr, "needed", r->out.needed);
22094                 ndr->depth++;
22095                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22096                 ndr->depth--;
22097                 ndr_print_WERROR(ndr, "result", r->out.result);
22098                 ndr->depth--;
22099         }
22100         ndr->depth--;
22101 }
22102
22103 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
22104 {
22105         if (flags & NDR_IN) {
22106                 if (r->in.handle == NULL) {
22107                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22108                 }
22109                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22110                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
22111                 if (r->in.architecture) {
22112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22115                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22116                 }
22117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22119                 if (r->in.buffer) {
22120                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22121                 }
22122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22123         }
22124         if (flags & NDR_OUT) {
22125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22126                 if (r->out.info) {
22127                         {
22128                                 struct ndr_push *_ndr_info;
22129                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22130                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22131                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22132                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22133                         }
22134                 }
22135                 if (r->out.needed == NULL) {
22136                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22137                 }
22138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22139                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22140         }
22141         return NDR_ERR_SUCCESS;
22142 }
22143
22144 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
22145 {
22146         uint32_t _ptr_architecture;
22147         uint32_t _ptr_buffer;
22148         uint32_t _ptr_info;
22149         TALLOC_CTX *_mem_save_handle_0;
22150         TALLOC_CTX *_mem_save_architecture_0;
22151         TALLOC_CTX *_mem_save_buffer_0;
22152         TALLOC_CTX *_mem_save_info_0;
22153         TALLOC_CTX *_mem_save_needed_0;
22154         if (flags & NDR_IN) {
22155                 ZERO_STRUCT(r->out);
22156
22157                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22158                         NDR_PULL_ALLOC(ndr, r->in.handle);
22159                 }
22160                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22161                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22162                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22163                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
22165                 if (_ptr_architecture) {
22166                         NDR_PULL_ALLOC(ndr, r->in.architecture);
22167                 } else {
22168                         r->in.architecture = NULL;
22169                 }
22170                 if (r->in.architecture) {
22171                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
22172                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
22173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22175                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22176                                 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));
22177                         }
22178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
22181                 }
22182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22183                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22184                 if (_ptr_buffer) {
22185                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22186                 } else {
22187                         r->in.buffer = NULL;
22188                 }
22189                 if (r->in.buffer) {
22190                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22191                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22192                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22194                 }
22195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22196                 NDR_PULL_ALLOC(ndr, r->out.needed);
22197                 ZERO_STRUCTP(r->out.needed);
22198         }
22199         if (flags & NDR_OUT) {
22200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22201                 if (_ptr_info) {
22202                         NDR_PULL_ALLOC(ndr, r->out.info);
22203                 } else {
22204                         r->out.info = NULL;
22205                 }
22206                 if (r->out.info) {
22207                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22208                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22209                         {
22210                                 struct ndr_pull *_ndr_info;
22211                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22212                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22213                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22214                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22215                         }
22216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22217                 }
22218                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22219                         NDR_PULL_ALLOC(ndr, r->out.needed);
22220                 }
22221                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22222                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22224                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22225                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22226         }
22227         return NDR_ERR_SUCCESS;
22228 }
22229
22230 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
22231 {
22232         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
22233         ndr->depth++;
22234         if (flags & NDR_SET_VALUES) {
22235                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22236         }
22237         if (flags & NDR_IN) {
22238                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
22239                 ndr->depth++;
22240                 ndr_print_ptr(ndr, "handle", r->in.handle);
22241                 ndr->depth++;
22242                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22243                 ndr->depth--;
22244                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
22245                 ndr->depth++;
22246                 if (r->in.architecture) {
22247                         ndr_print_string(ndr, "architecture", r->in.architecture);
22248                 }
22249                 ndr->depth--;
22250                 ndr_print_uint32(ndr, "level", r->in.level);
22251                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22252                 ndr->depth++;
22253                 if (r->in.buffer) {
22254                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22255                 }
22256                 ndr->depth--;
22257                 ndr_print_uint32(ndr, "offered", r->in.offered);
22258                 ndr->depth--;
22259         }
22260         if (flags & NDR_OUT) {
22261                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
22262                 ndr->depth++;
22263                 ndr_print_ptr(ndr, "info", r->out.info);
22264                 ndr->depth++;
22265                 if (r->out.info) {
22266                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22267                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22268                 }
22269                 ndr->depth--;
22270                 ndr_print_ptr(ndr, "needed", r->out.needed);
22271                 ndr->depth++;
22272                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22273                 ndr->depth--;
22274                 ndr_print_WERROR(ndr, "result", r->out.result);
22275                 ndr->depth--;
22276         }
22277         ndr->depth--;
22278 }
22279
22280 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22281 {
22282         if (flags & NDR_IN) {
22283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22284                 if (r->in.server) {
22285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22288                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22289                 }
22290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22291                 if (r->in.environment) {
22292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22294                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22295                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22296                 }
22297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22298                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22299                 if (r->in.buffer) {
22300                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22301                 }
22302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22303         }
22304         if (flags & NDR_OUT) {
22305                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22306                 if (r->out.info) {
22307                         {
22308                                 struct ndr_push *_ndr_info;
22309                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22310                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22311                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22312                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22313                         }
22314                 }
22315                 if (r->out.needed == NULL) {
22316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22317                 }
22318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22320         }
22321         return NDR_ERR_SUCCESS;
22322 }
22323
22324 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
22325 {
22326         uint32_t _ptr_server;
22327         uint32_t _ptr_environment;
22328         uint32_t _ptr_buffer;
22329         uint32_t _ptr_info;
22330         TALLOC_CTX *_mem_save_server_0;
22331         TALLOC_CTX *_mem_save_environment_0;
22332         TALLOC_CTX *_mem_save_buffer_0;
22333         TALLOC_CTX *_mem_save_info_0;
22334         TALLOC_CTX *_mem_save_needed_0;
22335         if (flags & NDR_IN) {
22336                 ZERO_STRUCT(r->out);
22337
22338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22339                 if (_ptr_server) {
22340                         NDR_PULL_ALLOC(ndr, r->in.server);
22341                 } else {
22342                         r->in.server = NULL;
22343                 }
22344                 if (r->in.server) {
22345                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22346                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22347                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22348                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22349                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22350                                 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));
22351                         }
22352                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22353                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22355                 }
22356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22357                 if (_ptr_environment) {
22358                         NDR_PULL_ALLOC(ndr, r->in.environment);
22359                 } else {
22360                         r->in.environment = NULL;
22361                 }
22362                 if (r->in.environment) {
22363                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22364                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22367                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22368                                 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));
22369                         }
22370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22373                 }
22374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22376                 if (_ptr_buffer) {
22377                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22378                 } else {
22379                         r->in.buffer = NULL;
22380                 }
22381                 if (r->in.buffer) {
22382                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22383                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22384                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22386                 }
22387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22388                 NDR_PULL_ALLOC(ndr, r->out.needed);
22389                 ZERO_STRUCTP(r->out.needed);
22390         }
22391         if (flags & NDR_OUT) {
22392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22393                 if (_ptr_info) {
22394                         NDR_PULL_ALLOC(ndr, r->out.info);
22395                 } else {
22396                         r->out.info = NULL;
22397                 }
22398                 if (r->out.info) {
22399                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22400                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22401                         {
22402                                 struct ndr_pull *_ndr_info;
22403                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22404                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22405                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22406                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22407                         }
22408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22409                 }
22410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22411                         NDR_PULL_ALLOC(ndr, r->out.needed);
22412                 }
22413                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22414                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22417                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22418         }
22419         return NDR_ERR_SUCCESS;
22420 }
22421
22422 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22423 {
22424         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22425         ndr->depth++;
22426         if (flags & NDR_SET_VALUES) {
22427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22428         }
22429         if (flags & NDR_IN) {
22430                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22431                 ndr->depth++;
22432                 ndr_print_ptr(ndr, "server", r->in.server);
22433                 ndr->depth++;
22434                 if (r->in.server) {
22435                         ndr_print_string(ndr, "server", r->in.server);
22436                 }
22437                 ndr->depth--;
22438                 ndr_print_ptr(ndr, "environment", r->in.environment);
22439                 ndr->depth++;
22440                 if (r->in.environment) {
22441                         ndr_print_string(ndr, "environment", r->in.environment);
22442                 }
22443                 ndr->depth--;
22444                 ndr_print_uint32(ndr, "level", r->in.level);
22445                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22446                 ndr->depth++;
22447                 if (r->in.buffer) {
22448                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22449                 }
22450                 ndr->depth--;
22451                 ndr_print_uint32(ndr, "offered", r->in.offered);
22452                 ndr->depth--;
22453         }
22454         if (flags & NDR_OUT) {
22455                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22456                 ndr->depth++;
22457                 ndr_print_ptr(ndr, "info", r->out.info);
22458                 ndr->depth++;
22459                 if (r->out.info) {
22460                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22461                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22462                 }
22463                 ndr->depth--;
22464                 ndr_print_ptr(ndr, "needed", r->out.needed);
22465                 ndr->depth++;
22466                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22467                 ndr->depth--;
22468                 ndr_print_WERROR(ndr, "result", r->out.result);
22469                 ndr->depth--;
22470         }
22471         ndr->depth--;
22472 }
22473
22474 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22475 {
22476         if (flags & NDR_IN) {
22477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22478                 if (r->in.server) {
22479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22480                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22482                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22483                 }
22484                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22485                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22486                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22487                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22488                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22489                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22490                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22491                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22492         }
22493         if (flags & NDR_OUT) {
22494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22495         }
22496         return NDR_ERR_SUCCESS;
22497 }
22498
22499 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22500 {
22501         uint32_t _ptr_server;
22502         TALLOC_CTX *_mem_save_server_0;
22503         if (flags & NDR_IN) {
22504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22505                 if (_ptr_server) {
22506                         NDR_PULL_ALLOC(ndr, r->in.server);
22507                 } else {
22508                         r->in.server = NULL;
22509                 }
22510                 if (r->in.server) {
22511                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22512                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22515                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22516                                 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));
22517                         }
22518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22521                 }
22522                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22523                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22524                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22525                         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));
22526                 }
22527                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22528                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22529                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22530                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22531                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22532                         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));
22533                 }
22534                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22535                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22536         }
22537         if (flags & NDR_OUT) {
22538                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22539         }
22540         return NDR_ERR_SUCCESS;
22541 }
22542
22543 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22544 {
22545         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22546         ndr->depth++;
22547         if (flags & NDR_SET_VALUES) {
22548                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22549         }
22550         if (flags & NDR_IN) {
22551                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22552                 ndr->depth++;
22553                 ndr_print_ptr(ndr, "server", r->in.server);
22554                 ndr->depth++;
22555                 if (r->in.server) {
22556                         ndr_print_string(ndr, "server", r->in.server);
22557                 }
22558                 ndr->depth--;
22559                 ndr_print_string(ndr, "architecture", r->in.architecture);
22560                 ndr_print_string(ndr, "driver", r->in.driver);
22561                 ndr->depth--;
22562         }
22563         if (flags & NDR_OUT) {
22564                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22565                 ndr->depth++;
22566                 ndr_print_WERROR(ndr, "result", r->out.result);
22567                 ndr->depth--;
22568         }
22569         ndr->depth--;
22570 }
22571
22572 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22573 {
22574         if (flags & NDR_IN) {
22575                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22576                 if (r->in.server) {
22577                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22578                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22579                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22580                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22581                 }
22582                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22583                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22584                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22585                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22586                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22587                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22588                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22589                 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));
22590                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22591                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22592                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22593                 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));
22594         }
22595         if (flags & NDR_OUT) {
22596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22597         }
22598         return NDR_ERR_SUCCESS;
22599 }
22600
22601 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22602 {
22603         uint32_t _ptr_server;
22604         TALLOC_CTX *_mem_save_server_0;
22605         if (flags & NDR_IN) {
22606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22607                 if (_ptr_server) {
22608                         NDR_PULL_ALLOC(ndr, r->in.server);
22609                 } else {
22610                         r->in.server = NULL;
22611                 }
22612                 if (r->in.server) {
22613                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22614                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22617                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22618                                 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));
22619                         }
22620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22623                 }
22624                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22625                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22626                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22627                         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));
22628                 }
22629                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22630                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22631                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22632                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22633                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22634                         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));
22635                 }
22636                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22637                 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));
22638                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22639                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22640                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22641                         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));
22642                 }
22643                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22644                 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));
22645         }
22646         if (flags & NDR_OUT) {
22647                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22648         }
22649         return NDR_ERR_SUCCESS;
22650 }
22651
22652 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22653 {
22654         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22655         ndr->depth++;
22656         if (flags & NDR_SET_VALUES) {
22657                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22658         }
22659         if (flags & NDR_IN) {
22660                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22661                 ndr->depth++;
22662                 ndr_print_ptr(ndr, "server", r->in.server);
22663                 ndr->depth++;
22664                 if (r->in.server) {
22665                         ndr_print_string(ndr, "server", r->in.server);
22666                 }
22667                 ndr->depth--;
22668                 ndr_print_string(ndr, "architecture", r->in.architecture);
22669                 ndr_print_string(ndr, "path_name", r->in.path_name);
22670                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22671                 ndr->depth--;
22672         }
22673         if (flags & NDR_OUT) {
22674                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22675                 ndr->depth++;
22676                 ndr_print_WERROR(ndr, "result", r->out.result);
22677                 ndr->depth--;
22678         }
22679         ndr->depth--;
22680 }
22681
22682 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22683 {
22684         if (flags & NDR_IN) {
22685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22686                 if (r->in.servername) {
22687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22691                 }
22692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22693                 if (r->in.environment) {
22694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22698                 }
22699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22701                 if (r->in.buffer) {
22702                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22703                 }
22704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22705         }
22706         if (flags & NDR_OUT) {
22707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22708                 if (r->out.info) {
22709                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22710                 }
22711                 if (r->out.needed == NULL) {
22712                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22713                 }
22714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22715                 if (r->out.count == NULL) {
22716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22717                 }
22718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22719                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22720         }
22721         return NDR_ERR_SUCCESS;
22722 }
22723
22724 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22725 {
22726         uint32_t _ptr_servername;
22727         uint32_t _ptr_environment;
22728         uint32_t _ptr_buffer;
22729         uint32_t _ptr_info;
22730         TALLOC_CTX *_mem_save_servername_0;
22731         TALLOC_CTX *_mem_save_environment_0;
22732         TALLOC_CTX *_mem_save_buffer_0;
22733         TALLOC_CTX *_mem_save_info_0;
22734         TALLOC_CTX *_mem_save_needed_0;
22735         TALLOC_CTX *_mem_save_count_0;
22736         if (flags & NDR_IN) {
22737                 ZERO_STRUCT(r->out);
22738
22739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22740                 if (_ptr_servername) {
22741                         NDR_PULL_ALLOC(ndr, r->in.servername);
22742                 } else {
22743                         r->in.servername = NULL;
22744                 }
22745                 if (r->in.servername) {
22746                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22747                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22748                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22749                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22750                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22751                                 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));
22752                         }
22753                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22754                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22755                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22756                 }
22757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22758                 if (_ptr_environment) {
22759                         NDR_PULL_ALLOC(ndr, r->in.environment);
22760                 } else {
22761                         r->in.environment = NULL;
22762                 }
22763                 if (r->in.environment) {
22764                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22765                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22766                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22767                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22768                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22769                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
22770                         }
22771                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22772                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22774                 }
22775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22777                 if (_ptr_buffer) {
22778                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22779                 } else {
22780                         r->in.buffer = NULL;
22781                 }
22782                 if (r->in.buffer) {
22783                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22784                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22785                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22787                 }
22788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22789                 NDR_PULL_ALLOC(ndr, r->out.needed);
22790                 ZERO_STRUCTP(r->out.needed);
22791                 NDR_PULL_ALLOC(ndr, r->out.count);
22792                 ZERO_STRUCTP(r->out.count);
22793         }
22794         if (flags & NDR_OUT) {
22795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22796                 if (_ptr_info) {
22797                         NDR_PULL_ALLOC(ndr, r->out.info);
22798                 } else {
22799                         r->out.info = NULL;
22800                 }
22801                 if (r->out.info) {
22802                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22803                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22804                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22806                 }
22807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22808                         NDR_PULL_ALLOC(ndr, r->out.needed);
22809                 }
22810                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22811                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22814                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22815                         NDR_PULL_ALLOC(ndr, r->out.count);
22816                 }
22817                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22818                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22820                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22821                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22822         }
22823         return NDR_ERR_SUCCESS;
22824 }
22825
22826 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22827 {
22828         uint32_t cntr_info_0;
22829         if (flags & NDR_IN) {
22830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22832         }
22833         if (flags & NDR_OUT) {
22834                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22835                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22836                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22837                 }
22838                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22839                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22840                 }
22841         }
22842         return NDR_ERR_SUCCESS;
22843 }
22844
22845 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22846 {
22847         uint32_t cntr_info_0;
22848         TALLOC_CTX *_mem_save_info_0;
22849         if (flags & NDR_IN) {
22850                 ZERO_STRUCT(r->out);
22851
22852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22854         }
22855         if (flags & NDR_OUT) {
22856                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22857                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22858                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22859                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22860                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22861                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22862                 }
22863                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22864                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22865                 }
22866                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22867         }
22868         return NDR_ERR_SUCCESS;
22869 }
22870
22871 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22872 {
22873         uint32_t cntr_info_2;
22874         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22875         ndr->depth++;
22876         if (flags & NDR_SET_VALUES) {
22877                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22878         }
22879         if (flags & NDR_IN) {
22880                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22881                 ndr->depth++;
22882                 ndr_print_ptr(ndr, "servername", r->in.servername);
22883                 ndr->depth++;
22884                 if (r->in.servername) {
22885                         ndr_print_string(ndr, "servername", r->in.servername);
22886                 }
22887                 ndr->depth--;
22888                 ndr_print_ptr(ndr, "environment", r->in.environment);
22889                 ndr->depth++;
22890                 if (r->in.environment) {
22891                         ndr_print_string(ndr, "environment", r->in.environment);
22892                 }
22893                 ndr->depth--;
22894                 ndr_print_uint32(ndr, "level", r->in.level);
22895                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22896                 ndr->depth++;
22897                 if (r->in.buffer) {
22898                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22899                 }
22900                 ndr->depth--;
22901                 ndr_print_uint32(ndr, "offered", r->in.offered);
22902                 ndr->depth--;
22903         }
22904         if (flags & NDR_OUT) {
22905                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22906                 ndr->depth++;
22907                 ndr_print_ptr(ndr, "count", r->out.count);
22908                 ndr->depth++;
22909                 ndr_print_uint32(ndr, "count", *r->out.count);
22910                 ndr->depth--;
22911                 ndr_print_ptr(ndr, "info", r->out.info);
22912                 ndr->depth++;
22913                 ndr_print_ptr(ndr, "info", *r->out.info);
22914                 ndr->depth++;
22915                 if (*r->out.info) {
22916                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22917                         ndr->depth++;
22918                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22919                                 char *idx_2=NULL;
22920                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22921                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22922                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22923                                         free(idx_2);
22924                                 }
22925                         }
22926                         ndr->depth--;
22927                 }
22928                 ndr->depth--;
22929                 ndr->depth--;
22930                 ndr_print_ptr(ndr, "needed", r->out.needed);
22931                 ndr->depth++;
22932                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22933                 ndr->depth--;
22934                 ndr_print_WERROR(ndr, "result", r->out.result);
22935                 ndr->depth--;
22936         }
22937         ndr->depth--;
22938 }
22939
22940 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22941 {
22942         if (flags & NDR_IN) {
22943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22944                 if (r->in.server) {
22945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22948                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22949                 }
22950                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22951                 if (r->in.environment) {
22952                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22953                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22955                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22956                 }
22957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22958                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22959                 if (r->in.buffer) {
22960                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22961                 }
22962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22963         }
22964         if (flags & NDR_OUT) {
22965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22966                 if (r->out.info) {
22967                         {
22968                                 struct ndr_push *_ndr_info;
22969                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22970                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22971                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22972                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22973                         }
22974                 }
22975                 if (r->out.needed == NULL) {
22976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22977                 }
22978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22980         }
22981         return NDR_ERR_SUCCESS;
22982 }
22983
22984 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22985 {
22986         uint32_t _ptr_server;
22987         uint32_t _ptr_environment;
22988         uint32_t _ptr_buffer;
22989         uint32_t _ptr_info;
22990         TALLOC_CTX *_mem_save_server_0;
22991         TALLOC_CTX *_mem_save_environment_0;
22992         TALLOC_CTX *_mem_save_buffer_0;
22993         TALLOC_CTX *_mem_save_info_0;
22994         TALLOC_CTX *_mem_save_needed_0;
22995         if (flags & NDR_IN) {
22996                 ZERO_STRUCT(r->out);
22997
22998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22999                 if (_ptr_server) {
23000                         NDR_PULL_ALLOC(ndr, r->in.server);
23001                 } else {
23002                         r->in.server = NULL;
23003                 }
23004                 if (r->in.server) {
23005                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
23006                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
23007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
23008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
23009                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
23010                                 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));
23011                         }
23012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
23013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
23014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
23015                 }
23016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
23017                 if (_ptr_environment) {
23018                         NDR_PULL_ALLOC(ndr, r->in.environment);
23019                 } else {
23020                         r->in.environment = NULL;
23021                 }
23022                 if (r->in.environment) {
23023                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
23024                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
23025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
23026                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
23027                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
23028                                 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));
23029                         }
23030                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
23031                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
23032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
23033                 }
23034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23036                 if (_ptr_buffer) {
23037                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23038                 } else {
23039                         r->in.buffer = NULL;
23040                 }
23041                 if (r->in.buffer) {
23042                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23043                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23044                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23045                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23046                 }
23047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23048                 NDR_PULL_ALLOC(ndr, r->out.needed);
23049                 ZERO_STRUCTP(r->out.needed);
23050         }
23051         if (flags & NDR_OUT) {
23052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23053                 if (_ptr_info) {
23054                         NDR_PULL_ALLOC(ndr, r->out.info);
23055                 } else {
23056                         r->out.info = NULL;
23057                 }
23058                 if (r->out.info) {
23059                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23060                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23061                         {
23062                                 struct ndr_pull *_ndr_info;
23063                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23064                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23065                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
23066                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23067                         }
23068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23069                 }
23070                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23071                         NDR_PULL_ALLOC(ndr, r->out.needed);
23072                 }
23073                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23074                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23076                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23077                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23078         }
23079         return NDR_ERR_SUCCESS;
23080 }
23081
23082 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
23083 {
23084         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
23085         ndr->depth++;
23086         if (flags & NDR_SET_VALUES) {
23087                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23088         }
23089         if (flags & NDR_IN) {
23090                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
23091                 ndr->depth++;
23092                 ndr_print_ptr(ndr, "server", r->in.server);
23093                 ndr->depth++;
23094                 if (r->in.server) {
23095                         ndr_print_string(ndr, "server", r->in.server);
23096                 }
23097                 ndr->depth--;
23098                 ndr_print_ptr(ndr, "environment", r->in.environment);
23099                 ndr->depth++;
23100                 if (r->in.environment) {
23101                         ndr_print_string(ndr, "environment", r->in.environment);
23102                 }
23103                 ndr->depth--;
23104                 ndr_print_uint32(ndr, "level", r->in.level);
23105                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23106                 ndr->depth++;
23107                 if (r->in.buffer) {
23108                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23109                 }
23110                 ndr->depth--;
23111                 ndr_print_uint32(ndr, "offered", r->in.offered);
23112                 ndr->depth--;
23113         }
23114         if (flags & NDR_OUT) {
23115                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
23116                 ndr->depth++;
23117                 ndr_print_ptr(ndr, "info", r->out.info);
23118                 ndr->depth++;
23119                 if (r->out.info) {
23120                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23121                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
23122                 }
23123                 ndr->depth--;
23124                 ndr_print_ptr(ndr, "needed", r->out.needed);
23125                 ndr->depth++;
23126                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23127                 ndr->depth--;
23128                 ndr_print_WERROR(ndr, "result", r->out.result);
23129                 ndr->depth--;
23130         }
23131         ndr->depth--;
23132 }
23133
23134 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
23135 {
23136         if (flags & NDR_IN) {
23137                 if (r->in.handle == NULL) {
23138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23139                 }
23140                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23142                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23143                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23144         }
23145         if (flags & NDR_OUT) {
23146                 if (r->out.job_id == NULL) {
23147                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23148                 }
23149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
23150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23151         }
23152         return NDR_ERR_SUCCESS;
23153 }
23154
23155 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
23156 {
23157         TALLOC_CTX *_mem_save_handle_0;
23158         TALLOC_CTX *_mem_save_job_id_0;
23159         if (flags & NDR_IN) {
23160                 ZERO_STRUCT(r->out);
23161
23162                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23163                         NDR_PULL_ALLOC(ndr, r->in.handle);
23164                 }
23165                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23166                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23167                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23170                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23171                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23172                 NDR_PULL_ALLOC(ndr, r->out.job_id);
23173                 ZERO_STRUCTP(r->out.job_id);
23174         }
23175         if (flags & NDR_OUT) {
23176                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23177                         NDR_PULL_ALLOC(ndr, r->out.job_id);
23178                 }
23179                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
23180                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
23181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
23182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
23183                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23184         }
23185         return NDR_ERR_SUCCESS;
23186 }
23187
23188 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
23189 {
23190         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
23191         ndr->depth++;
23192         if (flags & NDR_SET_VALUES) {
23193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23194         }
23195         if (flags & NDR_IN) {
23196                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
23197                 ndr->depth++;
23198                 ndr_print_ptr(ndr, "handle", r->in.handle);
23199                 ndr->depth++;
23200                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23201                 ndr->depth--;
23202                 ndr_print_uint32(ndr, "level", r->in.level);
23203                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23204                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
23205                 ndr->depth--;
23206         }
23207         if (flags & NDR_OUT) {
23208                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
23209                 ndr->depth++;
23210                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
23211                 ndr->depth++;
23212                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
23213                 ndr->depth--;
23214                 ndr_print_WERROR(ndr, "result", r->out.result);
23215                 ndr->depth--;
23216         }
23217         ndr->depth--;
23218 }
23219
23220 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
23221 {
23222         if (flags & NDR_IN) {
23223                 if (r->in.handle == NULL) {
23224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23225                 }
23226                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23227         }
23228         if (flags & NDR_OUT) {
23229                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23230         }
23231         return NDR_ERR_SUCCESS;
23232 }
23233
23234 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
23235 {
23236         TALLOC_CTX *_mem_save_handle_0;
23237         if (flags & NDR_IN) {
23238                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23239                         NDR_PULL_ALLOC(ndr, r->in.handle);
23240                 }
23241                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23242                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23243                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23244                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23245         }
23246         if (flags & NDR_OUT) {
23247                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23248         }
23249         return NDR_ERR_SUCCESS;
23250 }
23251
23252 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
23253 {
23254         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
23255         ndr->depth++;
23256         if (flags & NDR_SET_VALUES) {
23257                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23258         }
23259         if (flags & NDR_IN) {
23260                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
23261                 ndr->depth++;
23262                 ndr_print_ptr(ndr, "handle", r->in.handle);
23263                 ndr->depth++;
23264                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23265                 ndr->depth--;
23266                 ndr->depth--;
23267         }
23268         if (flags & NDR_OUT) {
23269                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
23270                 ndr->depth++;
23271                 ndr_print_WERROR(ndr, "result", r->out.result);
23272                 ndr->depth--;
23273         }
23274         ndr->depth--;
23275 }
23276
23277 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
23278 {
23279         if (flags & NDR_IN) {
23280                 if (r->in.handle == NULL) {
23281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23282                 }
23283                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23284                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
23286         }
23287         if (flags & NDR_OUT) {
23288                 if (r->out.num_written == NULL) {
23289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23290                 }
23291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
23292                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23293         }
23294         return NDR_ERR_SUCCESS;
23295 }
23296
23297 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
23298 {
23299         TALLOC_CTX *_mem_save_handle_0;
23300         TALLOC_CTX *_mem_save_num_written_0;
23301         if (flags & NDR_IN) {
23302                 ZERO_STRUCT(r->out);
23303
23304                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23305                         NDR_PULL_ALLOC(ndr, r->in.handle);
23306                 }
23307                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23308                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23309                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23311                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
23312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
23313                 NDR_PULL_ALLOC(ndr, r->out.num_written);
23314                 ZERO_STRUCTP(r->out.num_written);
23315         }
23316         if (flags & NDR_OUT) {
23317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23318                         NDR_PULL_ALLOC(ndr, r->out.num_written);
23319                 }
23320                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
23321                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
23322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
23323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
23324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23325         }
23326         return NDR_ERR_SUCCESS;
23327 }
23328
23329 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
23330 {
23331         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
23332         ndr->depth++;
23333         if (flags & NDR_SET_VALUES) {
23334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23335         }
23336         if (flags & NDR_IN) {
23337                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
23338                 ndr->depth++;
23339                 ndr_print_ptr(ndr, "handle", r->in.handle);
23340                 ndr->depth++;
23341                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23342                 ndr->depth--;
23343                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
23344                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
23345                 ndr->depth--;
23346         }
23347         if (flags & NDR_OUT) {
23348                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
23349                 ndr->depth++;
23350                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
23351                 ndr->depth++;
23352                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
23353                 ndr->depth--;
23354                 ndr_print_WERROR(ndr, "result", r->out.result);
23355                 ndr->depth--;
23356         }
23357         ndr->depth--;
23358 }
23359
23360 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
23361 {
23362         if (flags & NDR_IN) {
23363                 if (r->in.handle == NULL) {
23364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23365                 }
23366                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23367         }
23368         if (flags & NDR_OUT) {
23369                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23370         }
23371         return NDR_ERR_SUCCESS;
23372 }
23373
23374 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
23375 {
23376         TALLOC_CTX *_mem_save_handle_0;
23377         if (flags & NDR_IN) {
23378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23379                         NDR_PULL_ALLOC(ndr, r->in.handle);
23380                 }
23381                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23382                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23383                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23385         }
23386         if (flags & NDR_OUT) {
23387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23388         }
23389         return NDR_ERR_SUCCESS;
23390 }
23391
23392 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
23393 {
23394         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
23395         ndr->depth++;
23396         if (flags & NDR_SET_VALUES) {
23397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23398         }
23399         if (flags & NDR_IN) {
23400                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
23401                 ndr->depth++;
23402                 ndr_print_ptr(ndr, "handle", r->in.handle);
23403                 ndr->depth++;
23404                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23405                 ndr->depth--;
23406                 ndr->depth--;
23407         }
23408         if (flags & NDR_OUT) {
23409                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
23410                 ndr->depth++;
23411                 ndr_print_WERROR(ndr, "result", r->out.result);
23412                 ndr->depth--;
23413         }
23414         ndr->depth--;
23415 }
23416
23417 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
23418 {
23419         if (flags & NDR_IN) {
23420                 if (r->in.handle == NULL) {
23421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23422                 }
23423                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23424         }
23425         if (flags & NDR_OUT) {
23426                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23427         }
23428         return NDR_ERR_SUCCESS;
23429 }
23430
23431 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23432 {
23433         TALLOC_CTX *_mem_save_handle_0;
23434         if (flags & NDR_IN) {
23435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23436                         NDR_PULL_ALLOC(ndr, r->in.handle);
23437                 }
23438                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23439                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23440                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23442         }
23443         if (flags & NDR_OUT) {
23444                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23445         }
23446         return NDR_ERR_SUCCESS;
23447 }
23448
23449 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23450 {
23451         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23452         ndr->depth++;
23453         if (flags & NDR_SET_VALUES) {
23454                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23455         }
23456         if (flags & NDR_IN) {
23457                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23458                 ndr->depth++;
23459                 ndr_print_ptr(ndr, "handle", r->in.handle);
23460                 ndr->depth++;
23461                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23462                 ndr->depth--;
23463                 ndr->depth--;
23464         }
23465         if (flags & NDR_OUT) {
23466                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23467                 ndr->depth++;
23468                 ndr_print_WERROR(ndr, "result", r->out.result);
23469                 ndr->depth--;
23470         }
23471         ndr->depth--;
23472 }
23473
23474 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23475 {
23476         if (flags & NDR_IN) {
23477                 if (r->in.handle == NULL) {
23478                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23479                 }
23480                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23482         }
23483         if (flags & NDR_OUT) {
23484                 if (r->out.data == NULL) {
23485                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23486                 }
23487                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23488                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23489                 if (r->out._data_size == NULL) {
23490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23491                 }
23492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23493                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23494         }
23495         return NDR_ERR_SUCCESS;
23496 }
23497
23498 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23499 {
23500         TALLOC_CTX *_mem_save_handle_0;
23501         TALLOC_CTX *_mem_save__data_size_0;
23502         if (flags & NDR_IN) {
23503                 ZERO_STRUCT(r->out);
23504
23505                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23506                         NDR_PULL_ALLOC(ndr, r->in.handle);
23507                 }
23508                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23509                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23510                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23511                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23513                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23514                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23515                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23516                 ZERO_STRUCTP(r->out._data_size);
23517         }
23518         if (flags & NDR_OUT) {
23519                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23521                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23522                 }
23523                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23525                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23526                 }
23527                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23528                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23532                 if (r->out.data) {
23533                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23534                 }
23535         }
23536         return NDR_ERR_SUCCESS;
23537 }
23538
23539 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23540 {
23541         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23542         ndr->depth++;
23543         if (flags & NDR_SET_VALUES) {
23544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23545         }
23546         if (flags & NDR_IN) {
23547                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23548                 ndr->depth++;
23549                 ndr_print_ptr(ndr, "handle", r->in.handle);
23550                 ndr->depth++;
23551                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23552                 ndr->depth--;
23553                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23554                 ndr->depth--;
23555         }
23556         if (flags & NDR_OUT) {
23557                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23558                 ndr->depth++;
23559                 ndr_print_ptr(ndr, "data", r->out.data);
23560                 ndr->depth++;
23561                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23562                 ndr->depth--;
23563                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23564                 ndr->depth++;
23565                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23566                 ndr->depth--;
23567                 ndr_print_WERROR(ndr, "result", r->out.result);
23568                 ndr->depth--;
23569         }
23570         ndr->depth--;
23571 }
23572
23573 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23574 {
23575         if (flags & NDR_IN) {
23576                 if (r->in.handle == NULL) {
23577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23578                 }
23579                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23580         }
23581         if (flags & NDR_OUT) {
23582                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23583         }
23584         return NDR_ERR_SUCCESS;
23585 }
23586
23587 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23588 {
23589         TALLOC_CTX *_mem_save_handle_0;
23590         if (flags & NDR_IN) {
23591                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23592                         NDR_PULL_ALLOC(ndr, r->in.handle);
23593                 }
23594                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23595                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23596                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23597                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23598         }
23599         if (flags & NDR_OUT) {
23600                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23601         }
23602         return NDR_ERR_SUCCESS;
23603 }
23604
23605 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23606 {
23607         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23608         ndr->depth++;
23609         if (flags & NDR_SET_VALUES) {
23610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23611         }
23612         if (flags & NDR_IN) {
23613                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23614                 ndr->depth++;
23615                 ndr_print_ptr(ndr, "handle", r->in.handle);
23616                 ndr->depth++;
23617                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23618                 ndr->depth--;
23619                 ndr->depth--;
23620         }
23621         if (flags & NDR_OUT) {
23622                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23623                 ndr->depth++;
23624                 ndr_print_WERROR(ndr, "result", r->out.result);
23625                 ndr->depth--;
23626         }
23627         ndr->depth--;
23628 }
23629
23630 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23631 {
23632         if (flags & NDR_IN) {
23633                 if (r->in.handle == NULL) {
23634                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23635                 }
23636                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23639                 if (r->in.buffer) {
23640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23641                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23642                 }
23643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23644         }
23645         if (flags & NDR_OUT) {
23646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23647                 if (r->out.buffer) {
23648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23649                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23650                 }
23651                 if (r->out.needed == NULL) {
23652                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23653                 }
23654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23656         }
23657         return NDR_ERR_SUCCESS;
23658 }
23659
23660 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23661 {
23662         uint32_t _ptr_buffer;
23663         TALLOC_CTX *_mem_save_handle_0;
23664         TALLOC_CTX *_mem_save_buffer_0;
23665         TALLOC_CTX *_mem_save_needed_0;
23666         if (flags & NDR_IN) {
23667                 ZERO_STRUCT(r->out);
23668
23669                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23670                         NDR_PULL_ALLOC(ndr, r->in.handle);
23671                 }
23672                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23673                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23674                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23675                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23678                 if (_ptr_buffer) {
23679                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23680                 } else {
23681                         r->in.buffer = NULL;
23682                 }
23683                 if (r->in.buffer) {
23684                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23685                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23686                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23687                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23688                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23690                 }
23691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23692                 NDR_PULL_ALLOC(ndr, r->out.needed);
23693                 ZERO_STRUCTP(r->out.needed);
23694                 if (r->in.buffer) {
23695                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23696                 }
23697         }
23698         if (flags & NDR_OUT) {
23699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23700                 if (_ptr_buffer) {
23701                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23702                 } else {
23703                         r->out.buffer = NULL;
23704                 }
23705                 if (r->out.buffer) {
23706                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23707                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23708                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23709                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23710                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23712                 }
23713                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23714                         NDR_PULL_ALLOC(ndr, r->out.needed);
23715                 }
23716                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23717                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23719                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23721                 if (r->out.buffer) {
23722                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23723                 }
23724         }
23725         return NDR_ERR_SUCCESS;
23726 }
23727
23728 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23729 {
23730         ndr_print_struct(ndr, name, "spoolss_AddJob");
23731         ndr->depth++;
23732         if (flags & NDR_SET_VALUES) {
23733                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23734         }
23735         if (flags & NDR_IN) {
23736                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23737                 ndr->depth++;
23738                 ndr_print_ptr(ndr, "handle", r->in.handle);
23739                 ndr->depth++;
23740                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23741                 ndr->depth--;
23742                 ndr_print_uint32(ndr, "level", r->in.level);
23743                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23744                 ndr->depth++;
23745                 if (r->in.buffer) {
23746                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23747                 }
23748                 ndr->depth--;
23749                 ndr_print_uint32(ndr, "offered", r->in.offered);
23750                 ndr->depth--;
23751         }
23752         if (flags & NDR_OUT) {
23753                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23754                 ndr->depth++;
23755                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23756                 ndr->depth++;
23757                 if (r->out.buffer) {
23758                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23759                 }
23760                 ndr->depth--;
23761                 ndr_print_ptr(ndr, "needed", r->out.needed);
23762                 ndr->depth++;
23763                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23764                 ndr->depth--;
23765                 ndr_print_WERROR(ndr, "result", r->out.result);
23766                 ndr->depth--;
23767         }
23768         ndr->depth--;
23769 }
23770
23771 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23772 {
23773         if (flags & NDR_IN) {
23774                 if (r->in.handle == NULL) {
23775                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23776                 }
23777                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23779         }
23780         if (flags & NDR_OUT) {
23781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23782         }
23783         return NDR_ERR_SUCCESS;
23784 }
23785
23786 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23787 {
23788         TALLOC_CTX *_mem_save_handle_0;
23789         if (flags & NDR_IN) {
23790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23791                         NDR_PULL_ALLOC(ndr, r->in.handle);
23792                 }
23793                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23794                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23795                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23798         }
23799         if (flags & NDR_OUT) {
23800                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23801         }
23802         return NDR_ERR_SUCCESS;
23803 }
23804
23805 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23806 {
23807         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23808         ndr->depth++;
23809         if (flags & NDR_SET_VALUES) {
23810                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23811         }
23812         if (flags & NDR_IN) {
23813                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23814                 ndr->depth++;
23815                 ndr_print_ptr(ndr, "handle", r->in.handle);
23816                 ndr->depth++;
23817                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23818                 ndr->depth--;
23819                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23820                 ndr->depth--;
23821         }
23822         if (flags & NDR_OUT) {
23823                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23824                 ndr->depth++;
23825                 ndr_print_WERROR(ndr, "result", r->out.result);
23826                 ndr->depth--;
23827         }
23828         ndr->depth--;
23829 }
23830
23831 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
23832 {
23833         if (flags & NDR_IN) {
23834                 if (r->in.handle == NULL) {
23835                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23836                 }
23837                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23838                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23839                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23840                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23841                 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));
23842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23843         }
23844         if (flags & NDR_OUT) {
23845                 if (r->out.type == NULL) {
23846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23847                 }
23848                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23849                 if (r->out.data == NULL) {
23850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23851                 }
23852                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
23853                 if (r->out.needed == NULL) {
23854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23855                 }
23856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23857                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23858         }
23859         return NDR_ERR_SUCCESS;
23860 }
23861
23862 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
23863 {
23864         TALLOC_CTX *_mem_save_handle_0;
23865         TALLOC_CTX *_mem_save_type_0;
23866         TALLOC_CTX *_mem_save_data_0;
23867         TALLOC_CTX *_mem_save_needed_0;
23868         if (flags & NDR_IN) {
23869                 ZERO_STRUCT(r->out);
23870
23871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23872                         NDR_PULL_ALLOC(ndr, r->in.handle);
23873                 }
23874                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23878                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23879                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23880                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23881                         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));
23882                 }
23883                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23884                 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));
23885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23886                 NDR_PULL_ALLOC(ndr, r->out.type);
23887                 ZERO_STRUCTP(r->out.type);
23888                 NDR_PULL_ALLOC(ndr, r->out.data);
23889                 ZERO_STRUCTP(r->out.data);
23890                 NDR_PULL_ALLOC(ndr, r->out.needed);
23891                 ZERO_STRUCTP(r->out.needed);
23892         }
23893         if (flags & NDR_OUT) {
23894                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23895                         NDR_PULL_ALLOC(ndr, r->out.type);
23896                 }
23897                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23898                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23899                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23900                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23901                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23902                         NDR_PULL_ALLOC(ndr, r->out.data);
23903                 }
23904                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23905                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23906                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23908                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23909                         NDR_PULL_ALLOC(ndr, r->out.needed);
23910                 }
23911                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23912                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23914                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23915                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23916         }
23917         return NDR_ERR_SUCCESS;
23918 }
23919
23920 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23921 {
23922         if (flags & NDR_IN) {
23923                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23924         }
23925         if (flags & NDR_OUT) {
23926                 if (r->out.data == NULL) {
23927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23928                 }
23929                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23930                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23931         }
23932         return NDR_ERR_SUCCESS;
23933 }
23934
23935 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23936 {
23937         TALLOC_CTX *_mem_save_data_0;
23938         if (flags & NDR_IN) {
23939                 ZERO_STRUCT(r->out);
23940
23941                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23942                 NDR_PULL_ALLOC(ndr, r->out.data);
23943                 ZERO_STRUCTP(r->out.data);
23944         }
23945         if (flags & NDR_OUT) {
23946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23947                         NDR_PULL_ALLOC(ndr, r->out.data);
23948                 }
23949                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23950                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23951                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23952                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23953                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23954         }
23955         return NDR_ERR_SUCCESS;
23956 }
23957
23958 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23959 {
23960         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23961         ndr->depth++;
23962         if (flags & NDR_SET_VALUES) {
23963                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23964         }
23965         if (flags & NDR_IN) {
23966                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23967                 ndr->depth++;
23968                 ndr_print_ptr(ndr, "handle", r->in.handle);
23969                 ndr->depth++;
23970                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23971                 ndr->depth--;
23972                 ndr_print_string(ndr, "value_name", r->in.value_name);
23973                 ndr_print_uint32(ndr, "offered", r->in.offered);
23974                 ndr->depth--;
23975         }
23976         if (flags & NDR_OUT) {
23977                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23978                 ndr->depth++;
23979                 ndr_print_ptr(ndr, "type", r->out.type);
23980                 ndr->depth++;
23981                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23982                 ndr->depth--;
23983                 ndr_print_ptr(ndr, "data", r->out.data);
23984                 ndr->depth++;
23985                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23986                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23987                 ndr->depth--;
23988                 ndr_print_ptr(ndr, "needed", r->out.needed);
23989                 ndr->depth++;
23990                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23991                 ndr->depth--;
23992                 ndr_print_WERROR(ndr, "result", r->out.result);
23993                 ndr->depth--;
23994         }
23995         ndr->depth--;
23996 }
23997
23998 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23999 {
24000         if (flags & NDR_IN) {
24001                 if (r->in.handle == NULL) {
24002                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24003                 }
24004                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24005                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24006                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24007                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24008                 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));
24009                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24010                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
24011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
24012         }
24013         if (flags & NDR_OUT) {
24014                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24015         }
24016         return NDR_ERR_SUCCESS;
24017 }
24018
24019 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
24020 {
24021         if (flags & NDR_IN) {
24022                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24023         }
24024         if (flags & NDR_OUT) {
24025                 if (r->out.data == NULL) {
24026                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24027                 }
24028                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
24029                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
24030         }
24031         return NDR_ERR_SUCCESS;
24032 }
24033
24034 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
24035 {
24036         TALLOC_CTX *_mem_save_handle_0;
24037         if (flags & NDR_IN) {
24038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24039                         NDR_PULL_ALLOC(ndr, r->in.handle);
24040                 }
24041                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24042                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24043                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24045                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24046                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24047                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
24048                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
24049                 }
24050                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
24051                 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));
24052                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24053                 {
24054                         struct ndr_pull *_ndr_data;
24055                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
24056                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
24057                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
24058                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
24059                 }
24060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
24061         }
24062         if (flags & NDR_OUT) {
24063                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24064         }
24065         return NDR_ERR_SUCCESS;
24066 }
24067
24068 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
24069 {
24070         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
24071         ndr->depth++;
24072         if (flags & NDR_SET_VALUES) {
24073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24074         }
24075         if (flags & NDR_IN) {
24076                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
24077                 ndr->depth++;
24078                 ndr_print_ptr(ndr, "handle", r->in.handle);
24079                 ndr->depth++;
24080                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24081                 ndr->depth--;
24082                 ndr_print_string(ndr, "value_name", r->in.value_name);
24083                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24084                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
24085                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
24086                 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);
24087                 ndr->depth--;
24088         }
24089         if (flags & NDR_OUT) {
24090                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
24091                 ndr->depth++;
24092                 ndr_print_WERROR(ndr, "result", r->out.result);
24093                 ndr->depth--;
24094         }
24095         ndr->depth--;
24096 }
24097
24098 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
24099 {
24100         if (flags & NDR_IN) {
24101         }
24102         if (flags & NDR_OUT) {
24103                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24104         }
24105         return NDR_ERR_SUCCESS;
24106 }
24107
24108 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
24109 {
24110         if (flags & NDR_IN) {
24111         }
24112         if (flags & NDR_OUT) {
24113                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24114         }
24115         return NDR_ERR_SUCCESS;
24116 }
24117
24118 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
24119 {
24120         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
24121         ndr->depth++;
24122         if (flags & NDR_SET_VALUES) {
24123                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24124         }
24125         if (flags & NDR_IN) {
24126                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
24127                 ndr->depth++;
24128                 ndr->depth--;
24129         }
24130         if (flags & NDR_OUT) {
24131                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
24132                 ndr->depth++;
24133                 ndr_print_WERROR(ndr, "result", r->out.result);
24134                 ndr->depth--;
24135         }
24136         ndr->depth--;
24137 }
24138
24139 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
24140 {
24141         if (flags & NDR_IN) {
24142                 if (r->in.handle == NULL) {
24143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24144                 }
24145                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24146         }
24147         if (flags & NDR_OUT) {
24148                 if (r->out.handle == NULL) {
24149                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24150                 }
24151                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24152                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24153         }
24154         return NDR_ERR_SUCCESS;
24155 }
24156
24157 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
24158 {
24159         TALLOC_CTX *_mem_save_handle_0;
24160         if (flags & NDR_IN) {
24161                 ZERO_STRUCT(r->out);
24162
24163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24164                         NDR_PULL_ALLOC(ndr, r->in.handle);
24165                 }
24166                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24167                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24168                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24170                 NDR_PULL_ALLOC(ndr, r->out.handle);
24171                 *r->out.handle = *r->in.handle;
24172         }
24173         if (flags & NDR_OUT) {
24174                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24175                         NDR_PULL_ALLOC(ndr, r->out.handle);
24176                 }
24177                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24178                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24179                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24181                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24182         }
24183         return NDR_ERR_SUCCESS;
24184 }
24185
24186 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
24187 {
24188         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
24189         ndr->depth++;
24190         if (flags & NDR_SET_VALUES) {
24191                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24192         }
24193         if (flags & NDR_IN) {
24194                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
24195                 ndr->depth++;
24196                 ndr_print_ptr(ndr, "handle", r->in.handle);
24197                 ndr->depth++;
24198                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24199                 ndr->depth--;
24200                 ndr->depth--;
24201         }
24202         if (flags & NDR_OUT) {
24203                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
24204                 ndr->depth++;
24205                 ndr_print_ptr(ndr, "handle", r->out.handle);
24206                 ndr->depth++;
24207                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24208                 ndr->depth--;
24209                 ndr_print_WERROR(ndr, "result", r->out.result);
24210                 ndr->depth--;
24211         }
24212         ndr->depth--;
24213 }
24214
24215 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
24216 {
24217         if (flags & NDR_IN) {
24218                 if (r->in.handle == NULL) {
24219                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24220                 }
24221                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24223                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24224                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24225         }
24226         if (flags & NDR_OUT) {
24227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24228         }
24229         return NDR_ERR_SUCCESS;
24230 }
24231
24232 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
24233 {
24234         TALLOC_CTX *_mem_save_handle_0;
24235         if (flags & NDR_IN) {
24236                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24237                         NDR_PULL_ALLOC(ndr, r->in.handle);
24238                 }
24239                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24240                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24241                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24242                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24244                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24245                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24246         }
24247         if (flags & NDR_OUT) {
24248                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24249         }
24250         return NDR_ERR_SUCCESS;
24251 }
24252
24253 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
24254 {
24255         ndr_print_struct(ndr, name, "spoolss_AddForm");
24256         ndr->depth++;
24257         if (flags & NDR_SET_VALUES) {
24258                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24259         }
24260         if (flags & NDR_IN) {
24261                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
24262                 ndr->depth++;
24263                 ndr_print_ptr(ndr, "handle", r->in.handle);
24264                 ndr->depth++;
24265                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24266                 ndr->depth--;
24267                 ndr_print_uint32(ndr, "level", r->in.level);
24268                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24269                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24270                 ndr->depth--;
24271         }
24272         if (flags & NDR_OUT) {
24273                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
24274                 ndr->depth++;
24275                 ndr_print_WERROR(ndr, "result", r->out.result);
24276                 ndr->depth--;
24277         }
24278         ndr->depth--;
24279 }
24280
24281 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
24282 {
24283         if (flags & NDR_IN) {
24284                 if (r->in.handle == NULL) {
24285                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24286                 }
24287                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24288                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24289                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24290                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24291                 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));
24292         }
24293         if (flags & NDR_OUT) {
24294                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24295         }
24296         return NDR_ERR_SUCCESS;
24297 }
24298
24299 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
24300 {
24301         TALLOC_CTX *_mem_save_handle_0;
24302         if (flags & NDR_IN) {
24303                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24304                         NDR_PULL_ALLOC(ndr, r->in.handle);
24305                 }
24306                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24307                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24308                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24310                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24311                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24312                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24313                         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));
24314                 }
24315                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24316                 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));
24317         }
24318         if (flags & NDR_OUT) {
24319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24320         }
24321         return NDR_ERR_SUCCESS;
24322 }
24323
24324 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
24325 {
24326         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
24327         ndr->depth++;
24328         if (flags & NDR_SET_VALUES) {
24329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24330         }
24331         if (flags & NDR_IN) {
24332                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
24333                 ndr->depth++;
24334                 ndr_print_ptr(ndr, "handle", r->in.handle);
24335                 ndr->depth++;
24336                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24337                 ndr->depth--;
24338                 ndr_print_string(ndr, "form_name", r->in.form_name);
24339                 ndr->depth--;
24340         }
24341         if (flags & NDR_OUT) {
24342                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
24343                 ndr->depth++;
24344                 ndr_print_WERROR(ndr, "result", r->out.result);
24345                 ndr->depth--;
24346         }
24347         ndr->depth--;
24348 }
24349
24350 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
24351 {
24352         if (flags & NDR_IN) {
24353                 if (r->in.handle == NULL) {
24354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24355                 }
24356                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24357                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24358                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24359                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24360                 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));
24361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24363                 if (r->in.buffer) {
24364                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24365                 }
24366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24367         }
24368         if (flags & NDR_OUT) {
24369                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24370                 if (r->out.info) {
24371                         {
24372                                 struct ndr_push *_ndr_info;
24373                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24374                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24375                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24376                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24377                         }
24378                 }
24379                 if (r->out.needed == NULL) {
24380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24381                 }
24382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24383                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24384         }
24385         return NDR_ERR_SUCCESS;
24386 }
24387
24388 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
24389 {
24390         uint32_t _ptr_buffer;
24391         uint32_t _ptr_info;
24392         TALLOC_CTX *_mem_save_handle_0;
24393         TALLOC_CTX *_mem_save_buffer_0;
24394         TALLOC_CTX *_mem_save_info_0;
24395         TALLOC_CTX *_mem_save_needed_0;
24396         if (flags & NDR_IN) {
24397                 ZERO_STRUCT(r->out);
24398
24399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24400                         NDR_PULL_ALLOC(ndr, r->in.handle);
24401                 }
24402                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24403                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24404                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24406                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24407                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24408                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24409                         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));
24410                 }
24411                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24412                 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));
24413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24415                 if (_ptr_buffer) {
24416                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24417                 } else {
24418                         r->in.buffer = NULL;
24419                 }
24420                 if (r->in.buffer) {
24421                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24422                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24423                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24425                 }
24426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24427                 NDR_PULL_ALLOC(ndr, r->out.needed);
24428                 ZERO_STRUCTP(r->out.needed);
24429         }
24430         if (flags & NDR_OUT) {
24431                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24432                 if (_ptr_info) {
24433                         NDR_PULL_ALLOC(ndr, r->out.info);
24434                 } else {
24435                         r->out.info = NULL;
24436                 }
24437                 if (r->out.info) {
24438                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24439                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24440                         {
24441                                 struct ndr_pull *_ndr_info;
24442                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24443                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24444                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24445                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24446                         }
24447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24448                 }
24449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24450                         NDR_PULL_ALLOC(ndr, r->out.needed);
24451                 }
24452                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24453                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24456                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24457         }
24458         return NDR_ERR_SUCCESS;
24459 }
24460
24461 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
24462 {
24463         ndr_print_struct(ndr, name, "spoolss_GetForm");
24464         ndr->depth++;
24465         if (flags & NDR_SET_VALUES) {
24466                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24467         }
24468         if (flags & NDR_IN) {
24469                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
24470                 ndr->depth++;
24471                 ndr_print_ptr(ndr, "handle", r->in.handle);
24472                 ndr->depth++;
24473                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24474                 ndr->depth--;
24475                 ndr_print_string(ndr, "form_name", r->in.form_name);
24476                 ndr_print_uint32(ndr, "level", r->in.level);
24477                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24478                 ndr->depth++;
24479                 if (r->in.buffer) {
24480                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24481                 }
24482                 ndr->depth--;
24483                 ndr_print_uint32(ndr, "offered", r->in.offered);
24484                 ndr->depth--;
24485         }
24486         if (flags & NDR_OUT) {
24487                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24488                 ndr->depth++;
24489                 ndr_print_ptr(ndr, "info", r->out.info);
24490                 ndr->depth++;
24491                 if (r->out.info) {
24492                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24493                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24494                 }
24495                 ndr->depth--;
24496                 ndr_print_ptr(ndr, "needed", r->out.needed);
24497                 ndr->depth++;
24498                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24499                 ndr->depth--;
24500                 ndr_print_WERROR(ndr, "result", r->out.result);
24501                 ndr->depth--;
24502         }
24503         ndr->depth--;
24504 }
24505
24506 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24507 {
24508         if (flags & NDR_IN) {
24509                 if (r->in.handle == NULL) {
24510                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24511                 }
24512                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24513                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24514                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24515                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24516                 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));
24517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24518                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24519                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24520         }
24521         if (flags & NDR_OUT) {
24522                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24523         }
24524         return NDR_ERR_SUCCESS;
24525 }
24526
24527 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24528 {
24529         TALLOC_CTX *_mem_save_handle_0;
24530         if (flags & NDR_IN) {
24531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24532                         NDR_PULL_ALLOC(ndr, r->in.handle);
24533                 }
24534                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24535                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24536                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24538                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24539                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24540                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24541                         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));
24542                 }
24543                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24544                 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));
24545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24546                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24547                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24548         }
24549         if (flags & NDR_OUT) {
24550                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24551         }
24552         return NDR_ERR_SUCCESS;
24553 }
24554
24555 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24556 {
24557         ndr_print_struct(ndr, name, "spoolss_SetForm");
24558         ndr->depth++;
24559         if (flags & NDR_SET_VALUES) {
24560                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24561         }
24562         if (flags & NDR_IN) {
24563                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24564                 ndr->depth++;
24565                 ndr_print_ptr(ndr, "handle", r->in.handle);
24566                 ndr->depth++;
24567                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24568                 ndr->depth--;
24569                 ndr_print_string(ndr, "form_name", r->in.form_name);
24570                 ndr_print_uint32(ndr, "level", r->in.level);
24571                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24572                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24573                 ndr->depth--;
24574         }
24575         if (flags & NDR_OUT) {
24576                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24577                 ndr->depth++;
24578                 ndr_print_WERROR(ndr, "result", r->out.result);
24579                 ndr->depth--;
24580         }
24581         ndr->depth--;
24582 }
24583
24584 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24585 {
24586         if (flags & NDR_IN) {
24587                 if (r->in.handle == NULL) {
24588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24589                 }
24590                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24592                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24593                 if (r->in.buffer) {
24594                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24595                 }
24596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24597         }
24598         if (flags & NDR_OUT) {
24599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24600                 if (r->out.info) {
24601                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24602                 }
24603                 if (r->out.needed == NULL) {
24604                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24605                 }
24606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24607                 if (r->out.count == NULL) {
24608                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24609                 }
24610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24612         }
24613         return NDR_ERR_SUCCESS;
24614 }
24615
24616 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24617 {
24618         uint32_t _ptr_buffer;
24619         uint32_t _ptr_info;
24620         TALLOC_CTX *_mem_save_handle_0;
24621         TALLOC_CTX *_mem_save_buffer_0;
24622         TALLOC_CTX *_mem_save_info_0;
24623         TALLOC_CTX *_mem_save_needed_0;
24624         TALLOC_CTX *_mem_save_count_0;
24625         if (flags & NDR_IN) {
24626                 ZERO_STRUCT(r->out);
24627
24628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24629                         NDR_PULL_ALLOC(ndr, r->in.handle);
24630                 }
24631                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24632                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24637                 if (_ptr_buffer) {
24638                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24639                 } else {
24640                         r->in.buffer = NULL;
24641                 }
24642                 if (r->in.buffer) {
24643                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24644                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24645                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24647                 }
24648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24649                 NDR_PULL_ALLOC(ndr, r->out.needed);
24650                 ZERO_STRUCTP(r->out.needed);
24651                 NDR_PULL_ALLOC(ndr, r->out.count);
24652                 ZERO_STRUCTP(r->out.count);
24653         }
24654         if (flags & NDR_OUT) {
24655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24656                 if (_ptr_info) {
24657                         NDR_PULL_ALLOC(ndr, r->out.info);
24658                 } else {
24659                         r->out.info = NULL;
24660                 }
24661                 if (r->out.info) {
24662                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24663                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24664                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24665                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24666                 }
24667                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24668                         NDR_PULL_ALLOC(ndr, r->out.needed);
24669                 }
24670                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24671                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24673                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24675                         NDR_PULL_ALLOC(ndr, r->out.count);
24676                 }
24677                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24682         }
24683         return NDR_ERR_SUCCESS;
24684 }
24685
24686 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24687 {
24688         uint32_t cntr_info_0;
24689         if (flags & NDR_IN) {
24690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24692         }
24693         if (flags & NDR_OUT) {
24694                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24695                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24696                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24697                 }
24698                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24699                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24700                 }
24701         }
24702         return NDR_ERR_SUCCESS;
24703 }
24704
24705 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24706 {
24707         uint32_t cntr_info_0;
24708         TALLOC_CTX *_mem_save_info_0;
24709         if (flags & NDR_IN) {
24710                 ZERO_STRUCT(r->out);
24711
24712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24714         }
24715         if (flags & NDR_OUT) {
24716                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24717                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24718                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24719                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24720                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24721                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24722                 }
24723                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24724                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24725                 }
24726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24727         }
24728         return NDR_ERR_SUCCESS;
24729 }
24730
24731 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24732 {
24733         uint32_t cntr_info_2;
24734         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24735         ndr->depth++;
24736         if (flags & NDR_SET_VALUES) {
24737                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24738         }
24739         if (flags & NDR_IN) {
24740                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24741                 ndr->depth++;
24742                 ndr_print_ptr(ndr, "handle", r->in.handle);
24743                 ndr->depth++;
24744                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24745                 ndr->depth--;
24746                 ndr_print_uint32(ndr, "level", r->in.level);
24747                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24748                 ndr->depth++;
24749                 if (r->in.buffer) {
24750                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24751                 }
24752                 ndr->depth--;
24753                 ndr_print_uint32(ndr, "offered", r->in.offered);
24754                 ndr->depth--;
24755         }
24756         if (flags & NDR_OUT) {
24757                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24758                 ndr->depth++;
24759                 ndr_print_ptr(ndr, "count", r->out.count);
24760                 ndr->depth++;
24761                 ndr_print_uint32(ndr, "count", *r->out.count);
24762                 ndr->depth--;
24763                 ndr_print_ptr(ndr, "info", r->out.info);
24764                 ndr->depth++;
24765                 ndr_print_ptr(ndr, "info", *r->out.info);
24766                 ndr->depth++;
24767                 if (*r->out.info) {
24768                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24769                         ndr->depth++;
24770                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24771                                 char *idx_2=NULL;
24772                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24773                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24774                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24775                                         free(idx_2);
24776                                 }
24777                         }
24778                         ndr->depth--;
24779                 }
24780                 ndr->depth--;
24781                 ndr->depth--;
24782                 ndr_print_ptr(ndr, "needed", r->out.needed);
24783                 ndr->depth++;
24784                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24785                 ndr->depth--;
24786                 ndr_print_WERROR(ndr, "result", r->out.result);
24787                 ndr->depth--;
24788         }
24789         ndr->depth--;
24790 }
24791
24792 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24793 {
24794         if (flags & NDR_IN) {
24795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24796                 if (r->in.servername) {
24797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24799                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24800                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24801                 }
24802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24804                 if (r->in.buffer) {
24805                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24806                 }
24807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24808         }
24809         if (flags & NDR_OUT) {
24810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24811                 if (r->out.info) {
24812                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24813                 }
24814                 if (r->out.needed == NULL) {
24815                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24816                 }
24817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24818                 if (r->out.count == NULL) {
24819                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24820                 }
24821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24822                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24823         }
24824         return NDR_ERR_SUCCESS;
24825 }
24826
24827 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24828 {
24829         uint32_t _ptr_servername;
24830         uint32_t _ptr_buffer;
24831         uint32_t _ptr_info;
24832         TALLOC_CTX *_mem_save_servername_0;
24833         TALLOC_CTX *_mem_save_buffer_0;
24834         TALLOC_CTX *_mem_save_info_0;
24835         TALLOC_CTX *_mem_save_needed_0;
24836         TALLOC_CTX *_mem_save_count_0;
24837         if (flags & NDR_IN) {
24838                 ZERO_STRUCT(r->out);
24839
24840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24841                 if (_ptr_servername) {
24842                         NDR_PULL_ALLOC(ndr, r->in.servername);
24843                 } else {
24844                         r->in.servername = NULL;
24845                 }
24846                 if (r->in.servername) {
24847                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24848                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24851                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24852                                 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));
24853                         }
24854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24857                 }
24858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24860                 if (_ptr_buffer) {
24861                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24862                 } else {
24863                         r->in.buffer = NULL;
24864                 }
24865                 if (r->in.buffer) {
24866                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24867                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24868                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24870                 }
24871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24872                 NDR_PULL_ALLOC(ndr, r->out.needed);
24873                 ZERO_STRUCTP(r->out.needed);
24874                 NDR_PULL_ALLOC(ndr, r->out.count);
24875                 ZERO_STRUCTP(r->out.count);
24876         }
24877         if (flags & NDR_OUT) {
24878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24879                 if (_ptr_info) {
24880                         NDR_PULL_ALLOC(ndr, r->out.info);
24881                 } else {
24882                         r->out.info = NULL;
24883                 }
24884                 if (r->out.info) {
24885                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24886                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24887                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24889                 }
24890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24891                         NDR_PULL_ALLOC(ndr, r->out.needed);
24892                 }
24893                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24894                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24898                         NDR_PULL_ALLOC(ndr, r->out.count);
24899                 }
24900                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24901                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24904                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24905         }
24906         return NDR_ERR_SUCCESS;
24907 }
24908
24909 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24910 {
24911         uint32_t cntr_info_0;
24912         if (flags & NDR_IN) {
24913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24915         }
24916         if (flags & NDR_OUT) {
24917                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24918                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24919                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24920                 }
24921                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24922                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24923                 }
24924         }
24925         return NDR_ERR_SUCCESS;
24926 }
24927
24928 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24929 {
24930         uint32_t cntr_info_0;
24931         TALLOC_CTX *_mem_save_info_0;
24932         if (flags & NDR_IN) {
24933                 ZERO_STRUCT(r->out);
24934
24935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24937         }
24938         if (flags & NDR_OUT) {
24939                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24940                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24941                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24942                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24943                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24944                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24945                 }
24946                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24947                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24948                 }
24949                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24950         }
24951         return NDR_ERR_SUCCESS;
24952 }
24953
24954 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24955 {
24956         uint32_t cntr_info_2;
24957         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24958         ndr->depth++;
24959         if (flags & NDR_SET_VALUES) {
24960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24961         }
24962         if (flags & NDR_IN) {
24963                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24964                 ndr->depth++;
24965                 ndr_print_ptr(ndr, "servername", r->in.servername);
24966                 ndr->depth++;
24967                 if (r->in.servername) {
24968                         ndr_print_string(ndr, "servername", r->in.servername);
24969                 }
24970                 ndr->depth--;
24971                 ndr_print_uint32(ndr, "level", r->in.level);
24972                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24973                 ndr->depth++;
24974                 if (r->in.buffer) {
24975                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24976                 }
24977                 ndr->depth--;
24978                 ndr_print_uint32(ndr, "offered", r->in.offered);
24979                 ndr->depth--;
24980         }
24981         if (flags & NDR_OUT) {
24982                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24983                 ndr->depth++;
24984                 ndr_print_ptr(ndr, "count", r->out.count);
24985                 ndr->depth++;
24986                 ndr_print_uint32(ndr, "count", *r->out.count);
24987                 ndr->depth--;
24988                 ndr_print_ptr(ndr, "info", r->out.info);
24989                 ndr->depth++;
24990                 ndr_print_ptr(ndr, "info", *r->out.info);
24991                 ndr->depth++;
24992                 if (*r->out.info) {
24993                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24994                         ndr->depth++;
24995                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24996                                 char *idx_2=NULL;
24997                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24998                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24999                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25000                                         free(idx_2);
25001                                 }
25002                         }
25003                         ndr->depth--;
25004                 }
25005                 ndr->depth--;
25006                 ndr->depth--;
25007                 ndr_print_ptr(ndr, "needed", r->out.needed);
25008                 ndr->depth++;
25009                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25010                 ndr->depth--;
25011                 ndr_print_WERROR(ndr, "result", r->out.result);
25012                 ndr->depth--;
25013         }
25014         ndr->depth--;
25015 }
25016
25017 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
25018 {
25019         if (flags & NDR_IN) {
25020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25021                 if (r->in.servername) {
25022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25024                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25025                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25026                 }
25027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25029                 if (r->in.buffer) {
25030                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25031                 }
25032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25033         }
25034         if (flags & NDR_OUT) {
25035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25036                 if (r->out.info) {
25037                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25038                 }
25039                 if (r->out.needed == NULL) {
25040                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25041                 }
25042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25043                 if (r->out.count == NULL) {
25044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25045                 }
25046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25047                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25048         }
25049         return NDR_ERR_SUCCESS;
25050 }
25051
25052 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
25053 {
25054         uint32_t _ptr_servername;
25055         uint32_t _ptr_buffer;
25056         uint32_t _ptr_info;
25057         TALLOC_CTX *_mem_save_servername_0;
25058         TALLOC_CTX *_mem_save_buffer_0;
25059         TALLOC_CTX *_mem_save_info_0;
25060         TALLOC_CTX *_mem_save_needed_0;
25061         TALLOC_CTX *_mem_save_count_0;
25062         if (flags & NDR_IN) {
25063                 ZERO_STRUCT(r->out);
25064
25065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25066                 if (_ptr_servername) {
25067                         NDR_PULL_ALLOC(ndr, r->in.servername);
25068                 } else {
25069                         r->in.servername = NULL;
25070                 }
25071                 if (r->in.servername) {
25072                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25073                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25075                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25076                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25077                                 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));
25078                         }
25079                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25080                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25082                 }
25083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25085                 if (_ptr_buffer) {
25086                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25087                 } else {
25088                         r->in.buffer = NULL;
25089                 }
25090                 if (r->in.buffer) {
25091                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25092                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25093                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25095                 }
25096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25097                 NDR_PULL_ALLOC(ndr, r->out.needed);
25098                 ZERO_STRUCTP(r->out.needed);
25099                 NDR_PULL_ALLOC(ndr, r->out.count);
25100                 ZERO_STRUCTP(r->out.count);
25101         }
25102         if (flags & NDR_OUT) {
25103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25104                 if (_ptr_info) {
25105                         NDR_PULL_ALLOC(ndr, r->out.info);
25106                 } else {
25107                         r->out.info = NULL;
25108                 }
25109                 if (r->out.info) {
25110                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25111                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25112                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25114                 }
25115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25116                         NDR_PULL_ALLOC(ndr, r->out.needed);
25117                 }
25118                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25119                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25121                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25123                         NDR_PULL_ALLOC(ndr, r->out.count);
25124                 }
25125                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25126                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25130         }
25131         return NDR_ERR_SUCCESS;
25132 }
25133
25134 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
25135 {
25136         uint32_t cntr_info_0;
25137         if (flags & NDR_IN) {
25138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25140         }
25141         if (flags & NDR_OUT) {
25142                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25143                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25144                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25145                 }
25146                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25147                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25148                 }
25149         }
25150         return NDR_ERR_SUCCESS;
25151 }
25152
25153 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
25154 {
25155         uint32_t cntr_info_0;
25156         TALLOC_CTX *_mem_save_info_0;
25157         if (flags & NDR_IN) {
25158                 ZERO_STRUCT(r->out);
25159
25160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25162         }
25163         if (flags & NDR_OUT) {
25164                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25165                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25166                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25167                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25168                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25169                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25170                 }
25171                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25172                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25173                 }
25174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25175         }
25176         return NDR_ERR_SUCCESS;
25177 }
25178
25179 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
25180 {
25181         uint32_t cntr_info_2;
25182         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
25183         ndr->depth++;
25184         if (flags & NDR_SET_VALUES) {
25185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25186         }
25187         if (flags & NDR_IN) {
25188                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
25189                 ndr->depth++;
25190                 ndr_print_ptr(ndr, "servername", r->in.servername);
25191                 ndr->depth++;
25192                 if (r->in.servername) {
25193                         ndr_print_string(ndr, "servername", r->in.servername);
25194                 }
25195                 ndr->depth--;
25196                 ndr_print_uint32(ndr, "level", r->in.level);
25197                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25198                 ndr->depth++;
25199                 if (r->in.buffer) {
25200                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25201                 }
25202                 ndr->depth--;
25203                 ndr_print_uint32(ndr, "offered", r->in.offered);
25204                 ndr->depth--;
25205         }
25206         if (flags & NDR_OUT) {
25207                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
25208                 ndr->depth++;
25209                 ndr_print_ptr(ndr, "count", r->out.count);
25210                 ndr->depth++;
25211                 ndr_print_uint32(ndr, "count", *r->out.count);
25212                 ndr->depth--;
25213                 ndr_print_ptr(ndr, "info", r->out.info);
25214                 ndr->depth++;
25215                 ndr_print_ptr(ndr, "info", *r->out.info);
25216                 ndr->depth++;
25217                 if (*r->out.info) {
25218                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25219                         ndr->depth++;
25220                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25221                                 char *idx_2=NULL;
25222                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25223                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25224                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25225                                         free(idx_2);
25226                                 }
25227                         }
25228                         ndr->depth--;
25229                 }
25230                 ndr->depth--;
25231                 ndr->depth--;
25232                 ndr_print_ptr(ndr, "needed", r->out.needed);
25233                 ndr->depth++;
25234                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25235                 ndr->depth--;
25236                 ndr_print_WERROR(ndr, "result", r->out.result);
25237                 ndr->depth--;
25238         }
25239         ndr->depth--;
25240 }
25241
25242 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
25243 {
25244         if (flags & NDR_IN) {
25245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
25246                 if (r->in.server_name) {
25247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25250                         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));
25251                 }
25252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
25253                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25254                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25255                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25256                 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));
25257         }
25258         if (flags & NDR_OUT) {
25259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25260         }
25261         return NDR_ERR_SUCCESS;
25262 }
25263
25264 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
25265 {
25266         uint32_t _ptr_server_name;
25267         TALLOC_CTX *_mem_save_server_name_0;
25268         if (flags & NDR_IN) {
25269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
25270                 if (_ptr_server_name) {
25271                         NDR_PULL_ALLOC(ndr, r->in.server_name);
25272                 } else {
25273                         r->in.server_name = NULL;
25274                 }
25275                 if (r->in.server_name) {
25276                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25277                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
25278                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25279                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25280                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25281                                 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));
25282                         }
25283                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25284                         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));
25285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
25286                 }
25287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
25288                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
25289                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
25290                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
25291                         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));
25292                 }
25293                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
25294                 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));
25295         }
25296         if (flags & NDR_OUT) {
25297                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25298         }
25299         return NDR_ERR_SUCCESS;
25300 }
25301
25302 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
25303 {
25304         ndr_print_struct(ndr, name, "spoolss_AddPort");
25305         ndr->depth++;
25306         if (flags & NDR_SET_VALUES) {
25307                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25308         }
25309         if (flags & NDR_IN) {
25310                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
25311                 ndr->depth++;
25312                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
25313                 ndr->depth++;
25314                 if (r->in.server_name) {
25315                         ndr_print_string(ndr, "server_name", r->in.server_name);
25316                 }
25317                 ndr->depth--;
25318                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
25319                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
25320                 ndr->depth--;
25321         }
25322         if (flags & NDR_OUT) {
25323                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
25324                 ndr->depth++;
25325                 ndr_print_WERROR(ndr, "result", r->out.result);
25326                 ndr->depth--;
25327         }
25328         ndr->depth--;
25329 }
25330
25331 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
25332 {
25333         if (flags & NDR_IN) {
25334         }
25335         if (flags & NDR_OUT) {
25336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25337         }
25338         return NDR_ERR_SUCCESS;
25339 }
25340
25341 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
25342 {
25343         if (flags & NDR_IN) {
25344         }
25345         if (flags & NDR_OUT) {
25346                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25347         }
25348         return NDR_ERR_SUCCESS;
25349 }
25350
25351 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
25352 {
25353         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
25354         ndr->depth++;
25355         if (flags & NDR_SET_VALUES) {
25356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25357         }
25358         if (flags & NDR_IN) {
25359                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
25360                 ndr->depth++;
25361                 ndr->depth--;
25362         }
25363         if (flags & NDR_OUT) {
25364                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
25365                 ndr->depth++;
25366                 ndr_print_WERROR(ndr, "result", r->out.result);
25367                 ndr->depth--;
25368         }
25369         ndr->depth--;
25370 }
25371
25372 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
25373 {
25374         if (flags & NDR_IN) {
25375         }
25376         if (flags & NDR_OUT) {
25377                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25378         }
25379         return NDR_ERR_SUCCESS;
25380 }
25381
25382 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
25383 {
25384         if (flags & NDR_IN) {
25385         }
25386         if (flags & NDR_OUT) {
25387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25388         }
25389         return NDR_ERR_SUCCESS;
25390 }
25391
25392 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
25393 {
25394         ndr_print_struct(ndr, name, "spoolss_DeletePort");
25395         ndr->depth++;
25396         if (flags & NDR_SET_VALUES) {
25397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25398         }
25399         if (flags & NDR_IN) {
25400                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
25401                 ndr->depth++;
25402                 ndr->depth--;
25403         }
25404         if (flags & NDR_OUT) {
25405                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
25406                 ndr->depth++;
25407                 ndr_print_WERROR(ndr, "result", r->out.result);
25408                 ndr->depth--;
25409         }
25410         ndr->depth--;
25411 }
25412
25413 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
25414 {
25415         if (flags & NDR_IN) {
25416                 if (r->in.handle == NULL) {
25417                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25418                 }
25419                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25420                 if (r->in.devmode_ctr == NULL) {
25421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25422                 }
25423                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25424         }
25425         if (flags & NDR_OUT) {
25426                 if (r->out.gdi_handle == NULL) {
25427                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25428                 }
25429                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25430                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25431         }
25432         return NDR_ERR_SUCCESS;
25433 }
25434
25435 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
25436 {
25437         TALLOC_CTX *_mem_save_handle_0;
25438         TALLOC_CTX *_mem_save_gdi_handle_0;
25439         TALLOC_CTX *_mem_save_devmode_ctr_0;
25440         if (flags & NDR_IN) {
25441                 ZERO_STRUCT(r->out);
25442
25443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25444                         NDR_PULL_ALLOC(ndr, r->in.handle);
25445                 }
25446                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25447                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25448                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25451                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25452                 }
25453                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25454                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25455                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25457                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25458                 ZERO_STRUCTP(r->out.gdi_handle);
25459         }
25460         if (flags & NDR_OUT) {
25461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25462                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25463                 }
25464                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25465                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25466                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25468                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25469         }
25470         return NDR_ERR_SUCCESS;
25471 }
25472
25473 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25474 {
25475         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25476         ndr->depth++;
25477         if (flags & NDR_SET_VALUES) {
25478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25479         }
25480         if (flags & NDR_IN) {
25481                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25482                 ndr->depth++;
25483                 ndr_print_ptr(ndr, "handle", r->in.handle);
25484                 ndr->depth++;
25485                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25486                 ndr->depth--;
25487                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25488                 ndr->depth++;
25489                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25490                 ndr->depth--;
25491                 ndr->depth--;
25492         }
25493         if (flags & NDR_OUT) {
25494                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25495                 ndr->depth++;
25496                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25497                 ndr->depth++;
25498                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25499                 ndr->depth--;
25500                 ndr_print_WERROR(ndr, "result", r->out.result);
25501                 ndr->depth--;
25502         }
25503         ndr->depth--;
25504 }
25505
25506 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25507 {
25508         if (flags & NDR_IN) {
25509         }
25510         if (flags & NDR_OUT) {
25511                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25512         }
25513         return NDR_ERR_SUCCESS;
25514 }
25515
25516 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25517 {
25518         if (flags & NDR_IN) {
25519         }
25520         if (flags & NDR_OUT) {
25521                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25522         }
25523         return NDR_ERR_SUCCESS;
25524 }
25525
25526 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25527 {
25528         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25529         ndr->depth++;
25530         if (flags & NDR_SET_VALUES) {
25531                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25532         }
25533         if (flags & NDR_IN) {
25534                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25535                 ndr->depth++;
25536                 ndr->depth--;
25537         }
25538         if (flags & NDR_OUT) {
25539                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25540                 ndr->depth++;
25541                 ndr_print_WERROR(ndr, "result", r->out.result);
25542                 ndr->depth--;
25543         }
25544         ndr->depth--;
25545 }
25546
25547 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25548 {
25549         if (flags & NDR_IN) {
25550                 if (r->in.gdi_handle == NULL) {
25551                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25552                 }
25553                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25554         }
25555         if (flags & NDR_OUT) {
25556                 if (r->out.gdi_handle == NULL) {
25557                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25558                 }
25559                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25560                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25561         }
25562         return NDR_ERR_SUCCESS;
25563 }
25564
25565 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25566 {
25567         TALLOC_CTX *_mem_save_gdi_handle_0;
25568         if (flags & NDR_IN) {
25569                 ZERO_STRUCT(r->out);
25570
25571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25572                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25573                 }
25574                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25575                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25576                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25578                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25579                 *r->out.gdi_handle = *r->in.gdi_handle;
25580         }
25581         if (flags & NDR_OUT) {
25582                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25583                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25584                 }
25585                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25586                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25587                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25590         }
25591         return NDR_ERR_SUCCESS;
25592 }
25593
25594 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25595 {
25596         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25597         ndr->depth++;
25598         if (flags & NDR_SET_VALUES) {
25599                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25600         }
25601         if (flags & NDR_IN) {
25602                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25603                 ndr->depth++;
25604                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25605                 ndr->depth++;
25606                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25607                 ndr->depth--;
25608                 ndr->depth--;
25609         }
25610         if (flags & NDR_OUT) {
25611                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25612                 ndr->depth++;
25613                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25614                 ndr->depth++;
25615                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25616                 ndr->depth--;
25617                 ndr_print_WERROR(ndr, "result", r->out.result);
25618                 ndr->depth--;
25619         }
25620         ndr->depth--;
25621 }
25622
25623 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25624 {
25625         if (flags & NDR_IN) {
25626         }
25627         if (flags & NDR_OUT) {
25628                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25629         }
25630         return NDR_ERR_SUCCESS;
25631 }
25632
25633 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25634 {
25635         if (flags & NDR_IN) {
25636         }
25637         if (flags & NDR_OUT) {
25638                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25639         }
25640         return NDR_ERR_SUCCESS;
25641 }
25642
25643 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25644 {
25645         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25646         ndr->depth++;
25647         if (flags & NDR_SET_VALUES) {
25648                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25649         }
25650         if (flags & NDR_IN) {
25651                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25652                 ndr->depth++;
25653                 ndr->depth--;
25654         }
25655         if (flags & NDR_OUT) {
25656                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25657                 ndr->depth++;
25658                 ndr_print_WERROR(ndr, "result", r->out.result);
25659                 ndr->depth--;
25660         }
25661         ndr->depth--;
25662 }
25663
25664 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25665 {
25666         if (flags & NDR_IN) {
25667         }
25668         if (flags & NDR_OUT) {
25669                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25670         }
25671         return NDR_ERR_SUCCESS;
25672 }
25673
25674 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25675 {
25676         if (flags & NDR_IN) {
25677         }
25678         if (flags & NDR_OUT) {
25679                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25680         }
25681         return NDR_ERR_SUCCESS;
25682 }
25683
25684 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25685 {
25686         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25687         ndr->depth++;
25688         if (flags & NDR_SET_VALUES) {
25689                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25690         }
25691         if (flags & NDR_IN) {
25692                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25693                 ndr->depth++;
25694                 ndr->depth--;
25695         }
25696         if (flags & NDR_OUT) {
25697                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25698                 ndr->depth++;
25699                 ndr_print_WERROR(ndr, "result", r->out.result);
25700                 ndr->depth--;
25701         }
25702         ndr->depth--;
25703 }
25704
25705 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25706 {
25707         if (flags & NDR_IN) {
25708         }
25709         if (flags & NDR_OUT) {
25710                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25711         }
25712         return NDR_ERR_SUCCESS;
25713 }
25714
25715 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25716 {
25717         if (flags & NDR_IN) {
25718         }
25719         if (flags & NDR_OUT) {
25720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25721         }
25722         return NDR_ERR_SUCCESS;
25723 }
25724
25725 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25726 {
25727         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25728         ndr->depth++;
25729         if (flags & NDR_SET_VALUES) {
25730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25731         }
25732         if (flags & NDR_IN) {
25733                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25734                 ndr->depth++;
25735                 ndr->depth--;
25736         }
25737         if (flags & NDR_OUT) {
25738                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25739                 ndr->depth++;
25740                 ndr_print_WERROR(ndr, "result", r->out.result);
25741                 ndr->depth--;
25742         }
25743         ndr->depth--;
25744 }
25745
25746 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25747 {
25748         if (flags & NDR_IN) {
25749         }
25750         if (flags & NDR_OUT) {
25751                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25752         }
25753         return NDR_ERR_SUCCESS;
25754 }
25755
25756 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25757 {
25758         if (flags & NDR_IN) {
25759         }
25760         if (flags & NDR_OUT) {
25761                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25762         }
25763         return NDR_ERR_SUCCESS;
25764 }
25765
25766 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25767 {
25768         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25769         ndr->depth++;
25770         if (flags & NDR_SET_VALUES) {
25771                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25772         }
25773         if (flags & NDR_IN) {
25774                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25775                 ndr->depth++;
25776                 ndr->depth--;
25777         }
25778         if (flags & NDR_OUT) {
25779                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25780                 ndr->depth++;
25781                 ndr_print_WERROR(ndr, "result", r->out.result);
25782                 ndr->depth--;
25783         }
25784         ndr->depth--;
25785 }
25786
25787 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25788 {
25789         if (flags & NDR_IN) {
25790         }
25791         if (flags & NDR_OUT) {
25792                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25793         }
25794         return NDR_ERR_SUCCESS;
25795 }
25796
25797 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25798 {
25799         if (flags & NDR_IN) {
25800         }
25801         if (flags & NDR_OUT) {
25802                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25803         }
25804         return NDR_ERR_SUCCESS;
25805 }
25806
25807 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25808 {
25809         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25810         ndr->depth++;
25811         if (flags & NDR_SET_VALUES) {
25812                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25813         }
25814         if (flags & NDR_IN) {
25815                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25816                 ndr->depth++;
25817                 ndr->depth--;
25818         }
25819         if (flags & NDR_OUT) {
25820                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25821                 ndr->depth++;
25822                 ndr_print_WERROR(ndr, "result", r->out.result);
25823                 ndr->depth--;
25824         }
25825         ndr->depth--;
25826 }
25827
25828 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25829 {
25830         if (flags & NDR_IN) {
25831         }
25832         if (flags & NDR_OUT) {
25833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25834         }
25835         return NDR_ERR_SUCCESS;
25836 }
25837
25838 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25839 {
25840         if (flags & NDR_IN) {
25841         }
25842         if (flags & NDR_OUT) {
25843                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25844         }
25845         return NDR_ERR_SUCCESS;
25846 }
25847
25848 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25849 {
25850         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25851         ndr->depth++;
25852         if (flags & NDR_SET_VALUES) {
25853                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25854         }
25855         if (flags & NDR_IN) {
25856                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25857                 ndr->depth++;
25858                 ndr->depth--;
25859         }
25860         if (flags & NDR_OUT) {
25861                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25862                 ndr->depth++;
25863                 ndr_print_WERROR(ndr, "result", r->out.result);
25864                 ndr->depth--;
25865         }
25866         ndr->depth--;
25867 }
25868
25869 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25870 {
25871         if (flags & NDR_IN) {
25872         }
25873         if (flags & NDR_OUT) {
25874                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25875         }
25876         return NDR_ERR_SUCCESS;
25877 }
25878
25879 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25880 {
25881         if (flags & NDR_IN) {
25882         }
25883         if (flags & NDR_OUT) {
25884                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25885         }
25886         return NDR_ERR_SUCCESS;
25887 }
25888
25889 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25890 {
25891         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25892         ndr->depth++;
25893         if (flags & NDR_SET_VALUES) {
25894                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25895         }
25896         if (flags & NDR_IN) {
25897                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25898                 ndr->depth++;
25899                 ndr->depth--;
25900         }
25901         if (flags & NDR_OUT) {
25902                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25903                 ndr->depth++;
25904                 ndr_print_WERROR(ndr, "result", r->out.result);
25905                 ndr->depth--;
25906         }
25907         ndr->depth--;
25908 }
25909
25910 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25911 {
25912         if (flags & NDR_IN) {
25913         }
25914         if (flags & NDR_OUT) {
25915                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25916         }
25917         return NDR_ERR_SUCCESS;
25918 }
25919
25920 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25921 {
25922         if (flags & NDR_IN) {
25923         }
25924         if (flags & NDR_OUT) {
25925                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25926         }
25927         return NDR_ERR_SUCCESS;
25928 }
25929
25930 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25931 {
25932         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25933         ndr->depth++;
25934         if (flags & NDR_SET_VALUES) {
25935                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25936         }
25937         if (flags & NDR_IN) {
25938                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25939                 ndr->depth++;
25940                 ndr->depth--;
25941         }
25942         if (flags & NDR_OUT) {
25943                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25944                 ndr->depth++;
25945                 ndr_print_WERROR(ndr, "result", r->out.result);
25946                 ndr->depth--;
25947         }
25948         ndr->depth--;
25949 }
25950
25951 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25952 {
25953         if (flags & NDR_IN) {
25954                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25955                 if (r->in.servername) {
25956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25957                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25959                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25960                 }
25961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25962                 if (r->in.print_processor_name) {
25963                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25964                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25966                         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));
25967                 }
25968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25970                 if (r->in.buffer) {
25971                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25972                 }
25973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25974         }
25975         if (flags & NDR_OUT) {
25976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25977                 if (r->out.info) {
25978                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25979                 }
25980                 if (r->out.needed == NULL) {
25981                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25982                 }
25983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25984                 if (r->out.count == NULL) {
25985                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25986                 }
25987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25988                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25989         }
25990         return NDR_ERR_SUCCESS;
25991 }
25992
25993 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25994 {
25995         uint32_t _ptr_servername;
25996         uint32_t _ptr_print_processor_name;
25997         uint32_t _ptr_buffer;
25998         uint32_t _ptr_info;
25999         TALLOC_CTX *_mem_save_servername_0;
26000         TALLOC_CTX *_mem_save_print_processor_name_0;
26001         TALLOC_CTX *_mem_save_buffer_0;
26002         TALLOC_CTX *_mem_save_info_0;
26003         TALLOC_CTX *_mem_save_needed_0;
26004         TALLOC_CTX *_mem_save_count_0;
26005         if (flags & NDR_IN) {
26006                 ZERO_STRUCT(r->out);
26007
26008                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26009                 if (_ptr_servername) {
26010                         NDR_PULL_ALLOC(ndr, r->in.servername);
26011                 } else {
26012                         r->in.servername = NULL;
26013                 }
26014                 if (r->in.servername) {
26015                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26016                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26017                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26018                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26019                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26020                                 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));
26021                         }
26022                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26023                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26024                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26025                 }
26026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
26027                 if (_ptr_print_processor_name) {
26028                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
26029                 } else {
26030                         r->in.print_processor_name = NULL;
26031                 }
26032                 if (r->in.print_processor_name) {
26033                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
26034                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
26035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
26036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
26037                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
26038                                 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));
26039                         }
26040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
26041                         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));
26042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
26043                 }
26044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26046                 if (_ptr_buffer) {
26047                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26048                 } else {
26049                         r->in.buffer = NULL;
26050                 }
26051                 if (r->in.buffer) {
26052                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26053                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26054                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26056                 }
26057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26058                 NDR_PULL_ALLOC(ndr, r->out.needed);
26059                 ZERO_STRUCTP(r->out.needed);
26060                 NDR_PULL_ALLOC(ndr, r->out.count);
26061                 ZERO_STRUCTP(r->out.count);
26062         }
26063         if (flags & NDR_OUT) {
26064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26065                 if (_ptr_info) {
26066                         NDR_PULL_ALLOC(ndr, r->out.info);
26067                 } else {
26068                         r->out.info = NULL;
26069                 }
26070                 if (r->out.info) {
26071                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26072                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26073                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26075                 }
26076                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26077                         NDR_PULL_ALLOC(ndr, r->out.needed);
26078                 }
26079                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26080                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26082                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26084                         NDR_PULL_ALLOC(ndr, r->out.count);
26085                 }
26086                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26087                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26090                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26091         }
26092         return NDR_ERR_SUCCESS;
26093 }
26094
26095 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
26096 {
26097         uint32_t cntr_info_0;
26098         if (flags & NDR_IN) {
26099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26101         }
26102         if (flags & NDR_OUT) {
26103                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26104                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26105                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26106                 }
26107                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26108                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26109                 }
26110         }
26111         return NDR_ERR_SUCCESS;
26112 }
26113
26114 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
26115 {
26116         uint32_t cntr_info_0;
26117         TALLOC_CTX *_mem_save_info_0;
26118         if (flags & NDR_IN) {
26119                 ZERO_STRUCT(r->out);
26120
26121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26123         }
26124         if (flags & NDR_OUT) {
26125                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26126                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26127                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26128                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26129                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26130                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26131                 }
26132                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26133                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26134                 }
26135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26136         }
26137         return NDR_ERR_SUCCESS;
26138 }
26139
26140 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
26141 {
26142         uint32_t cntr_info_2;
26143         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
26144         ndr->depth++;
26145         if (flags & NDR_SET_VALUES) {
26146                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26147         }
26148         if (flags & NDR_IN) {
26149                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
26150                 ndr->depth++;
26151                 ndr_print_ptr(ndr, "servername", r->in.servername);
26152                 ndr->depth++;
26153                 if (r->in.servername) {
26154                         ndr_print_string(ndr, "servername", r->in.servername);
26155                 }
26156                 ndr->depth--;
26157                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
26158                 ndr->depth++;
26159                 if (r->in.print_processor_name) {
26160                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
26161                 }
26162                 ndr->depth--;
26163                 ndr_print_uint32(ndr, "level", r->in.level);
26164                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26165                 ndr->depth++;
26166                 if (r->in.buffer) {
26167                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26168                 }
26169                 ndr->depth--;
26170                 ndr_print_uint32(ndr, "offered", r->in.offered);
26171                 ndr->depth--;
26172         }
26173         if (flags & NDR_OUT) {
26174                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
26175                 ndr->depth++;
26176                 ndr_print_ptr(ndr, "count", r->out.count);
26177                 ndr->depth++;
26178                 ndr_print_uint32(ndr, "count", *r->out.count);
26179                 ndr->depth--;
26180                 ndr_print_ptr(ndr, "info", r->out.info);
26181                 ndr->depth++;
26182                 ndr_print_ptr(ndr, "info", *r->out.info);
26183                 ndr->depth++;
26184                 if (*r->out.info) {
26185                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26186                         ndr->depth++;
26187                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26188                                 char *idx_2=NULL;
26189                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26190                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
26191                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
26192                                         free(idx_2);
26193                                 }
26194                         }
26195                         ndr->depth--;
26196                 }
26197                 ndr->depth--;
26198                 ndr->depth--;
26199                 ndr_print_ptr(ndr, "needed", r->out.needed);
26200                 ndr->depth++;
26201                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26202                 ndr->depth--;
26203                 ndr_print_WERROR(ndr, "result", r->out.result);
26204                 ndr->depth--;
26205         }
26206         ndr->depth--;
26207 }
26208
26209 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
26210 {
26211         if (flags & NDR_IN) {
26212                 if (r->in.handle == NULL) {
26213                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26214                 }
26215                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26216                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
26217                 if (r->in.data_type) {
26218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26220                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26221                         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));
26222                 }
26223                 if (r->in.devmode_ctr == NULL) {
26224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26225                 }
26226                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26227         }
26228         if (flags & NDR_OUT) {
26229                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26230         }
26231         return NDR_ERR_SUCCESS;
26232 }
26233
26234 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
26235 {
26236         uint32_t _ptr_data_type;
26237         TALLOC_CTX *_mem_save_handle_0;
26238         TALLOC_CTX *_mem_save_data_type_0;
26239         TALLOC_CTX *_mem_save_devmode_ctr_0;
26240         if (flags & NDR_IN) {
26241                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26242                         NDR_PULL_ALLOC(ndr, r->in.handle);
26243                 }
26244                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26245                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26246                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26247                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
26249                 if (_ptr_data_type) {
26250                         NDR_PULL_ALLOC(ndr, r->in.data_type);
26251                 } else {
26252                         r->in.data_type = NULL;
26253                 }
26254                 if (r->in.data_type) {
26255                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26256                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
26257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
26258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
26259                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
26260                                 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));
26261                         }
26262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
26263                         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));
26264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
26265                 }
26266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26267                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26268                 }
26269                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26271                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26273         }
26274         if (flags & NDR_OUT) {
26275                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26276         }
26277         return NDR_ERR_SUCCESS;
26278 }
26279
26280 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
26281 {
26282         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
26283         ndr->depth++;
26284         if (flags & NDR_SET_VALUES) {
26285                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26286         }
26287         if (flags & NDR_IN) {
26288                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
26289                 ndr->depth++;
26290                 ndr_print_ptr(ndr, "handle", r->in.handle);
26291                 ndr->depth++;
26292                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26293                 ndr->depth--;
26294                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
26295                 ndr->depth++;
26296                 if (r->in.data_type) {
26297                         ndr_print_string(ndr, "data_type", r->in.data_type);
26298                 }
26299                 ndr->depth--;
26300                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26301                 ndr->depth++;
26302                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26303                 ndr->depth--;
26304                 ndr->depth--;
26305         }
26306         if (flags & NDR_OUT) {
26307                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
26308                 ndr->depth++;
26309                 ndr_print_WERROR(ndr, "result", r->out.result);
26310                 ndr->depth--;
26311         }
26312         ndr->depth--;
26313 }
26314
26315 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
26316 {
26317         if (flags & NDR_IN) {
26318                 if (r->in.handle == NULL) {
26319                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26320                 }
26321                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
26323                 if (r->in.architecture) {
26324                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26325                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26326                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26327                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26328                 }
26329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26331                 if (r->in.buffer) {
26332                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26333                 }
26334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
26336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
26337         }
26338         if (flags & NDR_OUT) {
26339                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26340                 if (r->out.info) {
26341                         {
26342                                 struct ndr_push *_ndr_info;
26343                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26344                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
26345                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26346                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26347                         }
26348                 }
26349                 if (r->out.needed == NULL) {
26350                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26351                 }
26352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26353                 if (r->out.server_major_version == NULL) {
26354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26355                 }
26356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
26357                 if (r->out.server_minor_version == NULL) {
26358                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26359                 }
26360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
26361                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26362         }
26363         return NDR_ERR_SUCCESS;
26364 }
26365
26366 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
26367 {
26368         uint32_t _ptr_architecture;
26369         uint32_t _ptr_buffer;
26370         uint32_t _ptr_info;
26371         TALLOC_CTX *_mem_save_handle_0;
26372         TALLOC_CTX *_mem_save_architecture_0;
26373         TALLOC_CTX *_mem_save_buffer_0;
26374         TALLOC_CTX *_mem_save_info_0;
26375         TALLOC_CTX *_mem_save_needed_0;
26376         TALLOC_CTX *_mem_save_server_major_version_0;
26377         TALLOC_CTX *_mem_save_server_minor_version_0;
26378         if (flags & NDR_IN) {
26379                 ZERO_STRUCT(r->out);
26380
26381                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26382                         NDR_PULL_ALLOC(ndr, r->in.handle);
26383                 }
26384                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26385                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26386                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
26389                 if (_ptr_architecture) {
26390                         NDR_PULL_ALLOC(ndr, r->in.architecture);
26391                 } else {
26392                         r->in.architecture = NULL;
26393                 }
26394                 if (r->in.architecture) {
26395                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
26396                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
26397                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26398                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26399                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26400                                 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));
26401                         }
26402                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26403                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
26405                 }
26406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26408                 if (_ptr_buffer) {
26409                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26410                 } else {
26411                         r->in.buffer = NULL;
26412                 }
26413                 if (r->in.buffer) {
26414                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26415                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26416                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26418                 }
26419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
26421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
26422                 NDR_PULL_ALLOC(ndr, r->out.needed);
26423                 ZERO_STRUCTP(r->out.needed);
26424                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26425                 ZERO_STRUCTP(r->out.server_major_version);
26426                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26427                 ZERO_STRUCTP(r->out.server_minor_version);
26428         }
26429         if (flags & NDR_OUT) {
26430                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26431                 if (_ptr_info) {
26432                         NDR_PULL_ALLOC(ndr, r->out.info);
26433                 } else {
26434                         r->out.info = NULL;
26435                 }
26436                 if (r->out.info) {
26437                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26438                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26439                         {
26440                                 struct ndr_pull *_ndr_info;
26441                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26442                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
26443                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26444                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26445                         }
26446                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26447                 }
26448                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26449                         NDR_PULL_ALLOC(ndr, r->out.needed);
26450                 }
26451                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26452                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26456                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26457                 }
26458                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26459                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
26460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
26461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
26462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26463                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26464                 }
26465                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26466                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26469                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26470         }
26471         return NDR_ERR_SUCCESS;
26472 }
26473
26474 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26475 {
26476         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26477         ndr->depth++;
26478         if (flags & NDR_SET_VALUES) {
26479                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26480         }
26481         if (flags & NDR_IN) {
26482                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26483                 ndr->depth++;
26484                 ndr_print_ptr(ndr, "handle", r->in.handle);
26485                 ndr->depth++;
26486                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26487                 ndr->depth--;
26488                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26489                 ndr->depth++;
26490                 if (r->in.architecture) {
26491                         ndr_print_string(ndr, "architecture", r->in.architecture);
26492                 }
26493                 ndr->depth--;
26494                 ndr_print_uint32(ndr, "level", r->in.level);
26495                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26496                 ndr->depth++;
26497                 if (r->in.buffer) {
26498                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26499                 }
26500                 ndr->depth--;
26501                 ndr_print_uint32(ndr, "offered", r->in.offered);
26502                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26503                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26504                 ndr->depth--;
26505         }
26506         if (flags & NDR_OUT) {
26507                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26508                 ndr->depth++;
26509                 ndr_print_ptr(ndr, "info", r->out.info);
26510                 ndr->depth++;
26511                 if (r->out.info) {
26512                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26513                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26514                 }
26515                 ndr->depth--;
26516                 ndr_print_ptr(ndr, "needed", r->out.needed);
26517                 ndr->depth++;
26518                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26519                 ndr->depth--;
26520                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26521                 ndr->depth++;
26522                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26523                 ndr->depth--;
26524                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26525                 ndr->depth++;
26526                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26527                 ndr->depth--;
26528                 ndr_print_WERROR(ndr, "result", r->out.result);
26529                 ndr->depth--;
26530         }
26531         ndr->depth--;
26532 }
26533
26534 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26535 {
26536         if (flags & NDR_IN) {
26537         }
26538         if (flags & NDR_OUT) {
26539                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26540         }
26541         return NDR_ERR_SUCCESS;
26542 }
26543
26544 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26545 {
26546         if (flags & NDR_IN) {
26547         }
26548         if (flags & NDR_OUT) {
26549                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26550         }
26551         return NDR_ERR_SUCCESS;
26552 }
26553
26554 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26555 {
26556         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26557         ndr->depth++;
26558         if (flags & NDR_SET_VALUES) {
26559                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26560         }
26561         if (flags & NDR_IN) {
26562                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26563                 ndr->depth++;
26564                 ndr->depth--;
26565         }
26566         if (flags & NDR_OUT) {
26567                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26568                 ndr->depth++;
26569                 ndr_print_WERROR(ndr, "result", r->out.result);
26570                 ndr->depth--;
26571         }
26572         ndr->depth--;
26573 }
26574
26575 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26576 {
26577         if (flags & NDR_IN) {
26578         }
26579         if (flags & NDR_OUT) {
26580                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26581         }
26582         return NDR_ERR_SUCCESS;
26583 }
26584
26585 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26586 {
26587         if (flags & NDR_IN) {
26588         }
26589         if (flags & NDR_OUT) {
26590                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26591         }
26592         return NDR_ERR_SUCCESS;
26593 }
26594
26595 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26596 {
26597         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26598         ndr->depth++;
26599         if (flags & NDR_SET_VALUES) {
26600                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26601         }
26602         if (flags & NDR_IN) {
26603                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26604                 ndr->depth++;
26605                 ndr->depth--;
26606         }
26607         if (flags & NDR_OUT) {
26608                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26609                 ndr->depth++;
26610                 ndr_print_WERROR(ndr, "result", r->out.result);
26611                 ndr->depth--;
26612         }
26613         ndr->depth--;
26614 }
26615
26616 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26617 {
26618         if (flags & NDR_IN) {
26619                 if (r->in.handle == NULL) {
26620                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26621                 }
26622                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26623         }
26624         if (flags & NDR_OUT) {
26625                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26626         }
26627         return NDR_ERR_SUCCESS;
26628 }
26629
26630 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26631 {
26632         TALLOC_CTX *_mem_save_handle_0;
26633         if (flags & NDR_IN) {
26634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26635                         NDR_PULL_ALLOC(ndr, r->in.handle);
26636                 }
26637                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26638                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26639                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26641         }
26642         if (flags & NDR_OUT) {
26643                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26644         }
26645         return NDR_ERR_SUCCESS;
26646 }
26647
26648 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26649 {
26650         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26651         ndr->depth++;
26652         if (flags & NDR_SET_VALUES) {
26653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26654         }
26655         if (flags & NDR_IN) {
26656                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26657                 ndr->depth++;
26658                 ndr_print_ptr(ndr, "handle", r->in.handle);
26659                 ndr->depth++;
26660                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26661                 ndr->depth--;
26662                 ndr->depth--;
26663         }
26664         if (flags & NDR_OUT) {
26665                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26666                 ndr->depth++;
26667                 ndr_print_WERROR(ndr, "result", r->out.result);
26668                 ndr->depth--;
26669         }
26670         ndr->depth--;
26671 }
26672
26673 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26674 {
26675         if (flags & NDR_IN) {
26676         }
26677         if (flags & NDR_OUT) {
26678                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26679         }
26680         return NDR_ERR_SUCCESS;
26681 }
26682
26683 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26684 {
26685         if (flags & NDR_IN) {
26686         }
26687         if (flags & NDR_OUT) {
26688                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26689         }
26690         return NDR_ERR_SUCCESS;
26691 }
26692
26693 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26694 {
26695         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26696         ndr->depth++;
26697         if (flags & NDR_SET_VALUES) {
26698                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26699         }
26700         if (flags & NDR_IN) {
26701                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26702                 ndr->depth++;
26703                 ndr->depth--;
26704         }
26705         if (flags & NDR_OUT) {
26706                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26707                 ndr->depth++;
26708                 ndr_print_WERROR(ndr, "result", r->out.result);
26709                 ndr->depth--;
26710         }
26711         ndr->depth--;
26712 }
26713
26714 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26715 {
26716         if (flags & NDR_IN) {
26717                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26718                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26719                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26720                 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));
26721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26722                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26725                 if (r->in.buffer) {
26726                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26727                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26728                 }
26729         }
26730         if (flags & NDR_OUT) {
26731                 if (r->out.handle == NULL) {
26732                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26733                 }
26734                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26735                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26736         }
26737         return NDR_ERR_SUCCESS;
26738 }
26739
26740 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26741 {
26742         uint32_t _ptr_buffer;
26743         TALLOC_CTX *_mem_save_buffer_0;
26744         TALLOC_CTX *_mem_save_handle_0;
26745         if (flags & NDR_IN) {
26746                 ZERO_STRUCT(r->out);
26747
26748                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26749                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26750                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26751                         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));
26752                 }
26753                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26754                 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));
26755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26756                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26758                 if (r->in.bufsize > 512) {
26759                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26760                 }
26761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26762                 if (_ptr_buffer) {
26763                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26764                 } else {
26765                         r->in.buffer = NULL;
26766                 }
26767                 if (r->in.buffer) {
26768                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26769                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26770                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26771                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26772                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26774                 }
26775                 NDR_PULL_ALLOC(ndr, r->out.handle);
26776                 ZERO_STRUCTP(r->out.handle);
26777                 if (r->in.buffer) {
26778                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26779                 }
26780         }
26781         if (flags & NDR_OUT) {
26782                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26783                         NDR_PULL_ALLOC(ndr, r->out.handle);
26784                 }
26785                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26786                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26787                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26788                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26789                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26790         }
26791         return NDR_ERR_SUCCESS;
26792 }
26793
26794 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26795 {
26796         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26797         ndr->depth++;
26798         if (flags & NDR_SET_VALUES) {
26799                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26800         }
26801         if (flags & NDR_IN) {
26802                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26803                 ndr->depth++;
26804                 ndr_print_string(ndr, "server_name", r->in.server_name);
26805                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26806                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26807                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26808                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26809                 ndr->depth++;
26810                 if (r->in.buffer) {
26811                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26812                 }
26813                 ndr->depth--;
26814                 ndr->depth--;
26815         }
26816         if (flags & NDR_OUT) {
26817                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26818                 ndr->depth++;
26819                 ndr_print_ptr(ndr, "handle", r->out.handle);
26820                 ndr->depth++;
26821                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26822                 ndr->depth--;
26823                 ndr_print_WERROR(ndr, "result", r->out.result);
26824                 ndr->depth--;
26825         }
26826         ndr->depth--;
26827 }
26828
26829 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26830 {
26831         if (flags & NDR_IN) {
26832                 if (r->in.handle == NULL) {
26833                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26834                 }
26835                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26836                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26839                 if (r->in.buffer) {
26840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26841                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26842                 }
26843         }
26844         if (flags & NDR_OUT) {
26845                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26846         }
26847         return NDR_ERR_SUCCESS;
26848 }
26849
26850 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26851 {
26852         uint32_t _ptr_buffer;
26853         TALLOC_CTX *_mem_save_handle_0;
26854         TALLOC_CTX *_mem_save_buffer_0;
26855         if (flags & NDR_IN) {
26856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26857                         NDR_PULL_ALLOC(ndr, r->in.handle);
26858                 }
26859                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26860                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26861                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26862                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26863                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26865                 if (r->in.bufsize > 512) {
26866                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26867                 }
26868                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26869                 if (_ptr_buffer) {
26870                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26871                 } else {
26872                         r->in.buffer = NULL;
26873                 }
26874                 if (r->in.buffer) {
26875                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26876                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26877                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26878                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26879                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26881                 }
26882                 if (r->in.buffer) {
26883                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26884                 }
26885         }
26886         if (flags & NDR_OUT) {
26887                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26888         }
26889         return NDR_ERR_SUCCESS;
26890 }
26891
26892 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26893 {
26894         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26895         ndr->depth++;
26896         if (flags & NDR_SET_VALUES) {
26897                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26898         }
26899         if (flags & NDR_IN) {
26900                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26901                 ndr->depth++;
26902                 ndr_print_ptr(ndr, "handle", r->in.handle);
26903                 ndr->depth++;
26904                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26905                 ndr->depth--;
26906                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26907                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26908                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26909                 ndr->depth++;
26910                 if (r->in.buffer) {
26911                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26912                 }
26913                 ndr->depth--;
26914                 ndr->depth--;
26915         }
26916         if (flags & NDR_OUT) {
26917                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26918                 ndr->depth++;
26919                 ndr_print_WERROR(ndr, "result", r->out.result);
26920                 ndr->depth--;
26921         }
26922         ndr->depth--;
26923 }
26924
26925 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26926 {
26927         if (flags & NDR_IN) {
26928                 if (r->in.handle == NULL) {
26929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26930                 }
26931                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26932         }
26933         if (flags & NDR_OUT) {
26934                 if (r->out.handle == NULL) {
26935                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26936                 }
26937                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26938                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26939         }
26940         return NDR_ERR_SUCCESS;
26941 }
26942
26943 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26944 {
26945         TALLOC_CTX *_mem_save_handle_0;
26946         if (flags & NDR_IN) {
26947                 ZERO_STRUCT(r->out);
26948
26949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26950                         NDR_PULL_ALLOC(ndr, r->in.handle);
26951                 }
26952                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26953                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26954                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26956                 NDR_PULL_ALLOC(ndr, r->out.handle);
26957                 *r->out.handle = *r->in.handle;
26958         }
26959         if (flags & NDR_OUT) {
26960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26961                         NDR_PULL_ALLOC(ndr, r->out.handle);
26962                 }
26963                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26964                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26965                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26968         }
26969         return NDR_ERR_SUCCESS;
26970 }
26971
26972 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26973 {
26974         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26975         ndr->depth++;
26976         if (flags & NDR_SET_VALUES) {
26977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26978         }
26979         if (flags & NDR_IN) {
26980                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26981                 ndr->depth++;
26982                 ndr_print_ptr(ndr, "handle", r->in.handle);
26983                 ndr->depth++;
26984                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26985                 ndr->depth--;
26986                 ndr->depth--;
26987         }
26988         if (flags & NDR_OUT) {
26989                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26990                 ndr->depth++;
26991                 ndr_print_ptr(ndr, "handle", r->out.handle);
26992                 ndr->depth++;
26993                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26994                 ndr->depth--;
26995                 ndr_print_WERROR(ndr, "result", r->out.result);
26996                 ndr->depth--;
26997         }
26998         ndr->depth--;
26999 }
27000
27001 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
27002 {
27003         if (flags & NDR_IN) {
27004         }
27005         if (flags & NDR_OUT) {
27006                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27007         }
27008         return NDR_ERR_SUCCESS;
27009 }
27010
27011 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
27012 {
27013         if (flags & NDR_IN) {
27014         }
27015         if (flags & NDR_OUT) {
27016                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27017         }
27018         return NDR_ERR_SUCCESS;
27019 }
27020
27021 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
27022 {
27023         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
27024         ndr->depth++;
27025         if (flags & NDR_SET_VALUES) {
27026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27027         }
27028         if (flags & NDR_IN) {
27029                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
27030                 ndr->depth++;
27031                 ndr->depth--;
27032         }
27033         if (flags & NDR_OUT) {
27034                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
27035                 ndr->depth++;
27036                 ndr_print_WERROR(ndr, "result", r->out.result);
27037                 ndr->depth--;
27038         }
27039         ndr->depth--;
27040 }
27041
27042 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27043 {
27044         if (flags & NDR_IN) {
27045         }
27046         if (flags & NDR_OUT) {
27047                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27048         }
27049         return NDR_ERR_SUCCESS;
27050 }
27051
27052 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27053 {
27054         if (flags & NDR_IN) {
27055         }
27056         if (flags & NDR_OUT) {
27057                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27058         }
27059         return NDR_ERR_SUCCESS;
27060 }
27061
27062 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27063 {
27064         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
27065         ndr->depth++;
27066         if (flags & NDR_SET_VALUES) {
27067                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27068         }
27069         if (flags & NDR_IN) {
27070                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
27071                 ndr->depth++;
27072                 ndr->depth--;
27073         }
27074         if (flags & NDR_OUT) {
27075                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
27076                 ndr->depth++;
27077                 ndr_print_WERROR(ndr, "result", r->out.result);
27078                 ndr->depth--;
27079         }
27080         ndr->depth--;
27081 }
27082
27083 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
27084 {
27085         if (flags & NDR_IN) {
27086         }
27087         if (flags & NDR_OUT) {
27088                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27089         }
27090         return NDR_ERR_SUCCESS;
27091 }
27092
27093 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
27094 {
27095         if (flags & NDR_IN) {
27096         }
27097         if (flags & NDR_OUT) {
27098                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27099         }
27100         return NDR_ERR_SUCCESS;
27101 }
27102
27103 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
27104 {
27105         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
27106         ndr->depth++;
27107         if (flags & NDR_SET_VALUES) {
27108                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27109         }
27110         if (flags & NDR_IN) {
27111                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
27112                 ndr->depth++;
27113                 ndr->depth--;
27114         }
27115         if (flags & NDR_OUT) {
27116                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
27117                 ndr->depth++;
27118                 ndr_print_WERROR(ndr, "result", r->out.result);
27119                 ndr->depth--;
27120         }
27121         ndr->depth--;
27122 }
27123
27124 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
27125 {
27126         if (flags & NDR_IN) {
27127         }
27128         if (flags & NDR_OUT) {
27129                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27130         }
27131         return NDR_ERR_SUCCESS;
27132 }
27133
27134 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
27135 {
27136         if (flags & NDR_IN) {
27137         }
27138         if (flags & NDR_OUT) {
27139                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27140         }
27141         return NDR_ERR_SUCCESS;
27142 }
27143
27144 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
27145 {
27146         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
27147         ndr->depth++;
27148         if (flags & NDR_SET_VALUES) {
27149                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27150         }
27151         if (flags & NDR_IN) {
27152                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
27153                 ndr->depth++;
27154                 ndr->depth--;
27155         }
27156         if (flags & NDR_OUT) {
27157                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
27158                 ndr->depth++;
27159                 ndr_print_WERROR(ndr, "result", r->out.result);
27160                 ndr->depth--;
27161         }
27162         ndr->depth--;
27163 }
27164
27165 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27166 {
27167         if (flags & NDR_IN) {
27168                 if (r->in.handle == NULL) {
27169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27170                 }
27171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27172                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
27174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
27175                 if (r->in.local_machine) {
27176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27179                         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));
27180                 }
27181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
27182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
27183                 if (r->in.notify_options) {
27184                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27185                 }
27186         }
27187         if (flags & NDR_OUT) {
27188                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27189         }
27190         return NDR_ERR_SUCCESS;
27191 }
27192
27193 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27194 {
27195         uint32_t _ptr_local_machine;
27196         uint32_t _ptr_notify_options;
27197         TALLOC_CTX *_mem_save_handle_0;
27198         TALLOC_CTX *_mem_save_local_machine_0;
27199         TALLOC_CTX *_mem_save_notify_options_0;
27200         if (flags & NDR_IN) {
27201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27202                         NDR_PULL_ALLOC(ndr, r->in.handle);
27203                 }
27204                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27205                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27206                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27208                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
27210                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
27211                 if (_ptr_local_machine) {
27212                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
27213                 } else {
27214                         r->in.local_machine = NULL;
27215                 }
27216                 if (r->in.local_machine) {
27217                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
27218                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
27219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
27220                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
27221                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
27222                                 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));
27223                         }
27224                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
27225                         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));
27226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
27227                 }
27228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
27229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
27230                 if (_ptr_notify_options) {
27231                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
27232                 } else {
27233                         r->in.notify_options = NULL;
27234                 }
27235                 if (r->in.notify_options) {
27236                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
27238                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
27240                 }
27241         }
27242         if (flags & NDR_OUT) {
27243                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27244         }
27245         return NDR_ERR_SUCCESS;
27246 }
27247
27248 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27249 {
27250         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27251         ndr->depth++;
27252         if (flags & NDR_SET_VALUES) {
27253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27254         }
27255         if (flags & NDR_IN) {
27256                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27257                 ndr->depth++;
27258                 ndr_print_ptr(ndr, "handle", r->in.handle);
27259                 ndr->depth++;
27260                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27261                 ndr->depth--;
27262                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27263                 ndr_print_uint32(ndr, "options", r->in.options);
27264                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
27265                 ndr->depth++;
27266                 if (r->in.local_machine) {
27267                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
27268                 }
27269                 ndr->depth--;
27270                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27271                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
27272                 ndr->depth++;
27273                 if (r->in.notify_options) {
27274                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
27275                 }
27276                 ndr->depth--;
27277                 ndr->depth--;
27278         }
27279         if (flags & NDR_OUT) {
27280                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27281                 ndr->depth++;
27282                 ndr_print_WERROR(ndr, "result", r->out.result);
27283                 ndr->depth--;
27284         }
27285         ndr->depth--;
27286 }
27287
27288 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27289 {
27290         if (flags & NDR_IN) {
27291                 if (r->in.handle == NULL) {
27292                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27293                 }
27294                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
27296                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
27298                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27299                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27300         }
27301         if (flags & NDR_OUT) {
27302                 if (r->out.reply_result == NULL) {
27303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27304                 }
27305                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
27306                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27307         }
27308         return NDR_ERR_SUCCESS;
27309 }
27310
27311 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
27312 {
27313         TALLOC_CTX *_mem_save_handle_0;
27314         TALLOC_CTX *_mem_save_reply_result_0;
27315         if (flags & NDR_IN) {
27316                 ZERO_STRUCT(r->out);
27317
27318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27319                         NDR_PULL_ALLOC(ndr, r->in.handle);
27320                 }
27321                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27323                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
27326                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
27328                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27329                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27330                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
27331                 ZERO_STRUCTP(r->out.reply_result);
27332         }
27333         if (flags & NDR_OUT) {
27334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27335                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
27336                 }
27337                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
27338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
27339                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
27340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
27341                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27342         }
27343         return NDR_ERR_SUCCESS;
27344 }
27345
27346 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27347 {
27348         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
27349         ndr->depth++;
27350         if (flags & NDR_SET_VALUES) {
27351                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27352         }
27353         if (flags & NDR_IN) {
27354                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
27355                 ndr->depth++;
27356                 ndr_print_ptr(ndr, "handle", r->in.handle);
27357                 ndr->depth++;
27358                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27359                 ndr->depth--;
27360                 ndr_print_uint32(ndr, "color", r->in.color);
27361                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27362                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
27363                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
27364                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
27365                 ndr->depth--;
27366         }
27367         if (flags & NDR_OUT) {
27368                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
27369                 ndr->depth++;
27370                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
27371                 ndr->depth++;
27372                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
27373                 ndr->depth--;
27374                 ndr_print_WERROR(ndr, "result", r->out.result);
27375                 ndr->depth--;
27376         }
27377         ndr->depth--;
27378 }
27379
27380 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27381 {
27382         if (flags & NDR_IN) {
27383                 if (r->in.handle == NULL) {
27384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27385                 }
27386                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
27388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
27389                 if (r->in.options) {
27390                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27391                 }
27392         }
27393         if (flags & NDR_OUT) {
27394                 if (r->out.info == NULL) {
27395                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27396                 }
27397                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
27398                 if (*r->out.info) {
27399                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27400                 }
27401                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27402         }
27403         return NDR_ERR_SUCCESS;
27404 }
27405
27406 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
27407 {
27408         uint32_t _ptr_options;
27409         uint32_t _ptr_info;
27410         TALLOC_CTX *_mem_save_handle_0;
27411         TALLOC_CTX *_mem_save_options_0;
27412         TALLOC_CTX *_mem_save_info_0;
27413         TALLOC_CTX *_mem_save_info_1;
27414         if (flags & NDR_IN) {
27415                 ZERO_STRUCT(r->out);
27416
27417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27418                         NDR_PULL_ALLOC(ndr, r->in.handle);
27419                 }
27420                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27421                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27422                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
27425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
27426                 if (_ptr_options) {
27427                         NDR_PULL_ALLOC(ndr, r->in.options);
27428                 } else {
27429                         r->in.options = NULL;
27430                 }
27431                 if (r->in.options) {
27432                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27433                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
27434                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
27436                 }
27437                 NDR_PULL_ALLOC(ndr, r->out.info);
27438                 ZERO_STRUCTP(r->out.info);
27439         }
27440         if (flags & NDR_OUT) {
27441                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27442                         NDR_PULL_ALLOC(ndr, r->out.info);
27443                 }
27444                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27445                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
27446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
27447                 if (_ptr_info) {
27448                         NDR_PULL_ALLOC(ndr, *r->out.info);
27449                 } else {
27450                         *r->out.info = NULL;
27451                 }
27452                 if (*r->out.info) {
27453                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
27454                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
27455                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
27457                 }
27458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
27459                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27460         }
27461         return NDR_ERR_SUCCESS;
27462 }
27463
27464 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27465 {
27466         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27467         ndr->depth++;
27468         if (flags & NDR_SET_VALUES) {
27469                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27470         }
27471         if (flags & NDR_IN) {
27472                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27473                 ndr->depth++;
27474                 ndr_print_ptr(ndr, "handle", r->in.handle);
27475                 ndr->depth++;
27476                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27477                 ndr->depth--;
27478                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
27479                 ndr_print_ptr(ndr, "options", r->in.options);
27480                 ndr->depth++;
27481                 if (r->in.options) {
27482                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27483                 }
27484                 ndr->depth--;
27485                 ndr->depth--;
27486         }
27487         if (flags & NDR_OUT) {
27488                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27489                 ndr->depth++;
27490                 ndr_print_ptr(ndr, "info", r->out.info);
27491                 ndr->depth++;
27492                 ndr_print_ptr(ndr, "info", *r->out.info);
27493                 ndr->depth++;
27494                 if (*r->out.info) {
27495                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27496                 }
27497                 ndr->depth--;
27498                 ndr->depth--;
27499                 ndr_print_WERROR(ndr, "result", r->out.result);
27500                 ndr->depth--;
27501         }
27502         ndr->depth--;
27503 }
27504
27505 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27506 {
27507         if (flags & NDR_IN) {
27508         }
27509         if (flags & NDR_OUT) {
27510                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27511         }
27512         return NDR_ERR_SUCCESS;
27513 }
27514
27515 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27516 {
27517         if (flags & NDR_IN) {
27518         }
27519         if (flags & NDR_OUT) {
27520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27521         }
27522         return NDR_ERR_SUCCESS;
27523 }
27524
27525 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27526 {
27527         ndr_print_struct(ndr, name, "spoolss_44");
27528         ndr->depth++;
27529         if (flags & NDR_SET_VALUES) {
27530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27531         }
27532         if (flags & NDR_IN) {
27533                 ndr_print_struct(ndr, "in", "spoolss_44");
27534                 ndr->depth++;
27535                 ndr->depth--;
27536         }
27537         if (flags & NDR_OUT) {
27538                 ndr_print_struct(ndr, "out", "spoolss_44");
27539                 ndr->depth++;
27540                 ndr_print_WERROR(ndr, "result", r->out.result);
27541                 ndr->depth--;
27542         }
27543         ndr->depth--;
27544 }
27545
27546 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27547 {
27548         if (flags & NDR_IN) {
27549                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27550                 if (r->in.printername) {
27551                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27552                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27553                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27554                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27555                 }
27556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27557                 if (r->in.datatype) {
27558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27559                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27562                 }
27563                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27564                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27566                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27567                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27568         }
27569         if (flags & NDR_OUT) {
27570                 if (r->out.handle == NULL) {
27571                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27572                 }
27573                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27575         }
27576         return NDR_ERR_SUCCESS;
27577 }
27578
27579 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27580 {
27581         uint32_t _ptr_printername;
27582         uint32_t _ptr_datatype;
27583         TALLOC_CTX *_mem_save_printername_0;
27584         TALLOC_CTX *_mem_save_datatype_0;
27585         TALLOC_CTX *_mem_save_handle_0;
27586         if (flags & NDR_IN) {
27587                 ZERO_STRUCT(r->out);
27588
27589                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27590                 if (_ptr_printername) {
27591                         NDR_PULL_ALLOC(ndr, r->in.printername);
27592                 } else {
27593                         r->in.printername = NULL;
27594                 }
27595                 if (r->in.printername) {
27596                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27597                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27598                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27599                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27600                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27601                                 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));
27602                         }
27603                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27604                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27606                 }
27607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27608                 if (_ptr_datatype) {
27609                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27610                 } else {
27611                         r->in.datatype = NULL;
27612                 }
27613                 if (r->in.datatype) {
27614                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27615                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27617                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27618                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27619                                 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));
27620                         }
27621                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27622                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27624                 }
27625                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27626                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27628                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27629                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27630                 NDR_PULL_ALLOC(ndr, r->out.handle);
27631                 ZERO_STRUCTP(r->out.handle);
27632         }
27633         if (flags & NDR_OUT) {
27634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27635                         NDR_PULL_ALLOC(ndr, r->out.handle);
27636                 }
27637                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27638                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27639                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27641                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27642         }
27643         return NDR_ERR_SUCCESS;
27644 }
27645
27646 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27647 {
27648         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27649         ndr->depth++;
27650         if (flags & NDR_SET_VALUES) {
27651                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27652         }
27653         if (flags & NDR_IN) {
27654                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27655                 ndr->depth++;
27656                 ndr_print_ptr(ndr, "printername", r->in.printername);
27657                 ndr->depth++;
27658                 if (r->in.printername) {
27659                         ndr_print_string(ndr, "printername", r->in.printername);
27660                 }
27661                 ndr->depth--;
27662                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27663                 ndr->depth++;
27664                 if (r->in.datatype) {
27665                         ndr_print_string(ndr, "datatype", r->in.datatype);
27666                 }
27667                 ndr->depth--;
27668                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27669                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27670                 ndr_print_uint32(ndr, "level", r->in.level);
27671                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27672                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27673                 ndr->depth--;
27674         }
27675         if (flags & NDR_OUT) {
27676                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27677                 ndr->depth++;
27678                 ndr_print_ptr(ndr, "handle", r->out.handle);
27679                 ndr->depth++;
27680                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27681                 ndr->depth--;
27682                 ndr_print_WERROR(ndr, "result", r->out.result);
27683                 ndr->depth--;
27684         }
27685         ndr->depth--;
27686 }
27687
27688 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27689 {
27690         if (flags & NDR_IN) {
27691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27692                 if (r->in.server) {
27693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27696                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27697                 }
27698                 if (r->in.info_ctr == NULL) {
27699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27700                 }
27701                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27702                 if (r->in.devmode_ctr == NULL) {
27703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27704                 }
27705                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27706                 if (r->in.secdesc_ctr == NULL) {
27707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27708                 }
27709                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27710                 if (r->in.userlevel_ctr == NULL) {
27711                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27712                 }
27713                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27714         }
27715         if (flags & NDR_OUT) {
27716                 if (r->out.handle == NULL) {
27717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27718                 }
27719                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27720                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27721         }
27722         return NDR_ERR_SUCCESS;
27723 }
27724
27725 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27726 {
27727         uint32_t _ptr_server;
27728         TALLOC_CTX *_mem_save_server_0;
27729         TALLOC_CTX *_mem_save_info_ctr_0;
27730         TALLOC_CTX *_mem_save_devmode_ctr_0;
27731         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27732         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27733         TALLOC_CTX *_mem_save_handle_0;
27734         if (flags & NDR_IN) {
27735                 ZERO_STRUCT(r->out);
27736
27737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27738                 if (_ptr_server) {
27739                         NDR_PULL_ALLOC(ndr, r->in.server);
27740                 } else {
27741                         r->in.server = NULL;
27742                 }
27743                 if (r->in.server) {
27744                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27745                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27746                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27747                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27748                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27749                                 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));
27750                         }
27751                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27752                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27754                 }
27755                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27756                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27757                 }
27758                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27759                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27760                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27762                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27763                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27764                 }
27765                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27766                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27767                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27770                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27771                 }
27772                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27773                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27774                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27777                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27778                 }
27779                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27781                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27783                 NDR_PULL_ALLOC(ndr, r->out.handle);
27784                 ZERO_STRUCTP(r->out.handle);
27785         }
27786         if (flags & NDR_OUT) {
27787                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27788                         NDR_PULL_ALLOC(ndr, r->out.handle);
27789                 }
27790                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27791                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27792                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27793                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27794                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27795         }
27796         return NDR_ERR_SUCCESS;
27797 }
27798
27799 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27800 {
27801         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27802         ndr->depth++;
27803         if (flags & NDR_SET_VALUES) {
27804                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27805         }
27806         if (flags & NDR_IN) {
27807                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27808                 ndr->depth++;
27809                 ndr_print_ptr(ndr, "server", r->in.server);
27810                 ndr->depth++;
27811                 if (r->in.server) {
27812                         ndr_print_string(ndr, "server", r->in.server);
27813                 }
27814                 ndr->depth--;
27815                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27816                 ndr->depth++;
27817                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27818                 ndr->depth--;
27819                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27820                 ndr->depth++;
27821                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27822                 ndr->depth--;
27823                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27824                 ndr->depth++;
27825                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27826                 ndr->depth--;
27827                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27828                 ndr->depth++;
27829                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27830                 ndr->depth--;
27831                 ndr->depth--;
27832         }
27833         if (flags & NDR_OUT) {
27834                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27835                 ndr->depth++;
27836                 ndr_print_ptr(ndr, "handle", r->out.handle);
27837                 ndr->depth++;
27838                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27839                 ndr->depth--;
27840                 ndr_print_WERROR(ndr, "result", r->out.result);
27841                 ndr->depth--;
27842         }
27843         ndr->depth--;
27844 }
27845
27846 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27847 {
27848         if (flags & NDR_IN) {
27849         }
27850         if (flags & NDR_OUT) {
27851                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27852         }
27853         return NDR_ERR_SUCCESS;
27854 }
27855
27856 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27857 {
27858         if (flags & NDR_IN) {
27859         }
27860         if (flags & NDR_OUT) {
27861                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27862         }
27863         return NDR_ERR_SUCCESS;
27864 }
27865
27866 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27867 {
27868         ndr_print_struct(ndr, name, "spoolss_47");
27869         ndr->depth++;
27870         if (flags & NDR_SET_VALUES) {
27871                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27872         }
27873         if (flags & NDR_IN) {
27874                 ndr_print_struct(ndr, "in", "spoolss_47");
27875                 ndr->depth++;
27876                 ndr->depth--;
27877         }
27878         if (flags & NDR_OUT) {
27879                 ndr_print_struct(ndr, "out", "spoolss_47");
27880                 ndr->depth++;
27881                 ndr_print_WERROR(ndr, "result", r->out.result);
27882                 ndr->depth--;
27883         }
27884         ndr->depth--;
27885 }
27886
27887 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27888 {
27889         if (flags & NDR_IN) {
27890                 if (r->in.handle == NULL) {
27891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27892                 }
27893                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27897         }
27898         if (flags & NDR_OUT) {
27899                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27900                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27901                 if (r->out.value_needed == NULL) {
27902                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27903                 }
27904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27905                 if (r->out.type == NULL) {
27906                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27907                 }
27908                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27909                 {
27910                         uint32_t _flags_save_uint8 = ndr->flags;
27911                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27912                         if (r->out.data == NULL) {
27913                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27914                         }
27915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27916                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27917                         ndr->flags = _flags_save_uint8;
27918                 }
27919                 if (r->out.data_needed == NULL) {
27920                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27921                 }
27922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27923                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27924         }
27925         return NDR_ERR_SUCCESS;
27926 }
27927
27928 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27929 {
27930         TALLOC_CTX *_mem_save_handle_0;
27931         TALLOC_CTX *_mem_save_value_needed_0;
27932         TALLOC_CTX *_mem_save_type_0;
27933         TALLOC_CTX *_mem_save_data_needed_0;
27934         if (flags & NDR_IN) {
27935                 ZERO_STRUCT(r->out);
27936
27937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27938                         NDR_PULL_ALLOC(ndr, r->in.handle);
27939                 }
27940                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27942                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27947                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27948                 ZERO_STRUCTP(r->out.value_needed);
27949                 NDR_PULL_ALLOC(ndr, r->out.type);
27950                 ZERO_STRUCTP(r->out.type);
27951                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27952                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27953                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27954                 ZERO_STRUCTP(r->out.data_needed);
27955         }
27956         if (flags & NDR_OUT) {
27957                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27958                 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));
27959                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27960                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27961                 }
27962                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27963                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27967                         NDR_PULL_ALLOC(ndr, r->out.type);
27968                 }
27969                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27970                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27971                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27973                 {
27974                         uint32_t _flags_save_uint8 = ndr->flags;
27975                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27977                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27978                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27979                         }
27980                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27981                         ndr->flags = _flags_save_uint8;
27982                 }
27983                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27984                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27985                 }
27986                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27987                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27989                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27990                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27991                 if (r->out.value_name) {
27992                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27993                 }
27994                 if (r->out.data) {
27995                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27996                 }
27997         }
27998         return NDR_ERR_SUCCESS;
27999 }
28000
28001 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
28002 {
28003         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
28004         ndr->depth++;
28005         if (flags & NDR_SET_VALUES) {
28006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28007         }
28008         if (flags & NDR_IN) {
28009                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
28010                 ndr->depth++;
28011                 ndr_print_ptr(ndr, "handle", r->in.handle);
28012                 ndr->depth++;
28013                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28014                 ndr->depth--;
28015                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
28016                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
28017                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
28018                 ndr->depth--;
28019         }
28020         if (flags & NDR_OUT) {
28021                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
28022                 ndr->depth++;
28023                 ndr_print_string(ndr, "value_name", r->out.value_name);
28024                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
28025                 ndr->depth++;
28026                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
28027                 ndr->depth--;
28028                 ndr_print_ptr(ndr, "type", r->out.type);
28029                 ndr->depth++;
28030                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28031                 ndr->depth--;
28032                 ndr_print_ptr(ndr, "data", r->out.data);
28033                 ndr->depth++;
28034                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
28035                 ndr->depth--;
28036                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
28037                 ndr->depth++;
28038                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
28039                 ndr->depth--;
28040                 ndr_print_WERROR(ndr, "result", r->out.result);
28041                 ndr->depth--;
28042         }
28043         ndr->depth--;
28044 }
28045
28046 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
28047 {
28048         if (flags & NDR_IN) {
28049                 if (r->in.handle == NULL) {
28050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28051                 }
28052                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28053                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28054                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28055                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28056                 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));
28057         }
28058         if (flags & NDR_OUT) {
28059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28060         }
28061         return NDR_ERR_SUCCESS;
28062 }
28063
28064 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
28065 {
28066         TALLOC_CTX *_mem_save_handle_0;
28067         if (flags & NDR_IN) {
28068                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28069                         NDR_PULL_ALLOC(ndr, r->in.handle);
28070                 }
28071                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28072                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28073                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28074                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28075                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28076                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28077                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28078                         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));
28079                 }
28080                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28081                 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));
28082         }
28083         if (flags & NDR_OUT) {
28084                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28085         }
28086         return NDR_ERR_SUCCESS;
28087 }
28088
28089 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
28090 {
28091         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
28092         ndr->depth++;
28093         if (flags & NDR_SET_VALUES) {
28094                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28095         }
28096         if (flags & NDR_IN) {
28097                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
28098                 ndr->depth++;
28099                 ndr_print_ptr(ndr, "handle", r->in.handle);
28100                 ndr->depth++;
28101                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28102                 ndr->depth--;
28103                 ndr_print_string(ndr, "value_name", r->in.value_name);
28104                 ndr->depth--;
28105         }
28106         if (flags & NDR_OUT) {
28107                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
28108                 ndr->depth++;
28109                 ndr_print_WERROR(ndr, "result", r->out.result);
28110                 ndr->depth--;
28111         }
28112         ndr->depth--;
28113 }
28114
28115 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
28116 {
28117         if (flags & NDR_IN) {
28118         }
28119         if (flags & NDR_OUT) {
28120                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28121         }
28122         return NDR_ERR_SUCCESS;
28123 }
28124
28125 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
28126 {
28127         if (flags & NDR_IN) {
28128         }
28129         if (flags & NDR_OUT) {
28130                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28131         }
28132         return NDR_ERR_SUCCESS;
28133 }
28134
28135 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
28136 {
28137         ndr_print_struct(ndr, name, "spoolss_4a");
28138         ndr->depth++;
28139         if (flags & NDR_SET_VALUES) {
28140                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28141         }
28142         if (flags & NDR_IN) {
28143                 ndr_print_struct(ndr, "in", "spoolss_4a");
28144                 ndr->depth++;
28145                 ndr->depth--;
28146         }
28147         if (flags & NDR_OUT) {
28148                 ndr_print_struct(ndr, "out", "spoolss_4a");
28149                 ndr->depth++;
28150                 ndr_print_WERROR(ndr, "result", r->out.result);
28151                 ndr->depth--;
28152         }
28153         ndr->depth--;
28154 }
28155
28156 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
28157 {
28158         if (flags & NDR_IN) {
28159         }
28160         if (flags & NDR_OUT) {
28161                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28162         }
28163         return NDR_ERR_SUCCESS;
28164 }
28165
28166 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
28167 {
28168         if (flags & NDR_IN) {
28169         }
28170         if (flags & NDR_OUT) {
28171                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28172         }
28173         return NDR_ERR_SUCCESS;
28174 }
28175
28176 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
28177 {
28178         ndr_print_struct(ndr, name, "spoolss_4b");
28179         ndr->depth++;
28180         if (flags & NDR_SET_VALUES) {
28181                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28182         }
28183         if (flags & NDR_IN) {
28184                 ndr_print_struct(ndr, "in", "spoolss_4b");
28185                 ndr->depth++;
28186                 ndr->depth--;
28187         }
28188         if (flags & NDR_OUT) {
28189                 ndr_print_struct(ndr, "out", "spoolss_4b");
28190                 ndr->depth++;
28191                 ndr_print_WERROR(ndr, "result", r->out.result);
28192                 ndr->depth--;
28193         }
28194         ndr->depth--;
28195 }
28196
28197 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
28198 {
28199         if (flags & NDR_IN) {
28200         }
28201         if (flags & NDR_OUT) {
28202                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28203         }
28204         return NDR_ERR_SUCCESS;
28205 }
28206
28207 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
28208 {
28209         if (flags & NDR_IN) {
28210         }
28211         if (flags & NDR_OUT) {
28212                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28213         }
28214         return NDR_ERR_SUCCESS;
28215 }
28216
28217 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
28218 {
28219         ndr_print_struct(ndr, name, "spoolss_4c");
28220         ndr->depth++;
28221         if (flags & NDR_SET_VALUES) {
28222                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28223         }
28224         if (flags & NDR_IN) {
28225                 ndr_print_struct(ndr, "in", "spoolss_4c");
28226                 ndr->depth++;
28227                 ndr->depth--;
28228         }
28229         if (flags & NDR_OUT) {
28230                 ndr_print_struct(ndr, "out", "spoolss_4c");
28231                 ndr->depth++;
28232                 ndr_print_WERROR(ndr, "result", r->out.result);
28233                 ndr->depth--;
28234         }
28235         ndr->depth--;
28236 }
28237
28238 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterDataEx *r)
28239 {
28240         if (flags & NDR_IN) {
28241                 if (r->in.handle == NULL) {
28242                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28243                 }
28244                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28245                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28246                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28247                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28248                 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));
28249                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28250                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28251                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28252                 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));
28253                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28254                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
28255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
28256         }
28257         if (flags & NDR_OUT) {
28258                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28259         }
28260         return NDR_ERR_SUCCESS;
28261 }
28262
28263 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterDataEx *r)
28264 {
28265         if (flags & NDR_IN) {
28266                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28267         }
28268         if (flags & NDR_OUT) {
28269                 if (r->out.data == NULL) {
28270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28271                 }
28272                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28273                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28274         }
28275         return NDR_ERR_SUCCESS;
28276 }
28277
28278 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
28279 {
28280         TALLOC_CTX *_mem_save_handle_0;
28281         if (flags & NDR_IN) {
28282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28283                         NDR_PULL_ALLOC(ndr, r->in.handle);
28284                 }
28285                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28286                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28287                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28289                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28290                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28291                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28292                         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));
28293                 }
28294                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28295                 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));
28296                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28297                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28298                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28299                         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));
28300                 }
28301                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28302                 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));
28303                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28304                 {
28305                         struct ndr_pull *_ndr_data;
28306                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
28307                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
28308                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
28309                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
28310                 }
28311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
28312         }
28313         if (flags & NDR_OUT) {
28314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28315         }
28316         return NDR_ERR_SUCCESS;
28317 }
28318
28319 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
28320 {
28321         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
28322         ndr->depth++;
28323         if (flags & NDR_SET_VALUES) {
28324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28325         }
28326         if (flags & NDR_IN) {
28327                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
28328                 ndr->depth++;
28329                 ndr_print_ptr(ndr, "handle", r->in.handle);
28330                 ndr->depth++;
28331                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28332                 ndr->depth--;
28333                 ndr_print_string(ndr, "key_name", r->in.key_name);
28334                 ndr_print_string(ndr, "value_name", r->in.value_name);
28335                 ndr_print_winreg_Type(ndr, "type", r->in.type);
28336                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
28337                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
28338                 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);
28339                 ndr->depth--;
28340         }
28341         if (flags & NDR_OUT) {
28342                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
28343                 ndr->depth++;
28344                 ndr_print_WERROR(ndr, "result", r->out.result);
28345                 ndr->depth--;
28346         }
28347         ndr->depth--;
28348 }
28349
28350 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterDataEx *r)
28351 {
28352         if (flags & NDR_IN) {
28353                 if (r->in.handle == NULL) {
28354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28355                 }
28356                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28357                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28358                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28359                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28360                 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));
28361                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28362                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28363                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28364                 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));
28365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28366         }
28367         if (flags & NDR_OUT) {
28368                 if (r->out.type == NULL) {
28369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28370                 }
28371                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28372                 if (r->out.data == NULL) {
28373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28374                 }
28375                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
28376                 if (r->out.needed == NULL) {
28377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28378                 }
28379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28380                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28381         }
28382         return NDR_ERR_SUCCESS;
28383 }
28384
28385 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterDataEx *r)
28386 {
28387         TALLOC_CTX *_mem_save_handle_0;
28388         TALLOC_CTX *_mem_save_type_0;
28389         TALLOC_CTX *_mem_save_data_0;
28390         TALLOC_CTX *_mem_save_needed_0;
28391         if (flags & NDR_IN) {
28392                 ZERO_STRUCT(r->out);
28393
28394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28395                         NDR_PULL_ALLOC(ndr, r->in.handle);
28396                 }
28397                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28398                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28399                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28400                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28401                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28402                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28403                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28404                         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));
28405                 }
28406                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28407                 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));
28408                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28409                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28410                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28411                         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));
28412                 }
28413                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28414                 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));
28415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28416                 NDR_PULL_ALLOC(ndr, r->out.type);
28417                 ZERO_STRUCTP(r->out.type);
28418                 NDR_PULL_ALLOC(ndr, r->out.data);
28419                 ZERO_STRUCTP(r->out.data);
28420                 NDR_PULL_ALLOC(ndr, r->out.needed);
28421                 ZERO_STRUCTP(r->out.needed);
28422         }
28423         if (flags & NDR_OUT) {
28424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28425                         NDR_PULL_ALLOC(ndr, r->out.type);
28426                 }
28427                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28428                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28429                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28431                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28432                         NDR_PULL_ALLOC(ndr, r->out.data);
28433                 }
28434                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28435                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28436                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
28437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28439                         NDR_PULL_ALLOC(ndr, r->out.needed);
28440                 }
28441                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28442                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28445                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28446         }
28447         return NDR_ERR_SUCCESS;
28448 }
28449
28450 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterDataEx *r)
28451 {
28452         if (flags & NDR_IN) {
28453                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28454         }
28455         if (flags & NDR_OUT) {
28456                 if (r->out.data == NULL) {
28457                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28458                 }
28459                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28460                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28461         }
28462         return NDR_ERR_SUCCESS;
28463 }
28464
28465 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterDataEx *r)
28466 {
28467         TALLOC_CTX *_mem_save_data_0;
28468         if (flags & NDR_IN) {
28469                 ZERO_STRUCT(r->out);
28470
28471                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28472                 NDR_PULL_ALLOC(ndr, r->out.data);
28473                 ZERO_STRUCTP(r->out.data);
28474         }
28475         if (flags & NDR_OUT) {
28476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28477                         NDR_PULL_ALLOC(ndr, r->out.data);
28478                 }
28479                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28480                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28481                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
28482                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28483                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28484         }
28485         return NDR_ERR_SUCCESS;
28486 }
28487
28488 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28489 {
28490         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28491         ndr->depth++;
28492         if (flags & NDR_SET_VALUES) {
28493                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28494         }
28495         if (flags & NDR_IN) {
28496                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28497                 ndr->depth++;
28498                 ndr_print_ptr(ndr, "handle", r->in.handle);
28499                 ndr->depth++;
28500                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28501                 ndr->depth--;
28502                 ndr_print_string(ndr, "key_name", r->in.key_name);
28503                 ndr_print_string(ndr, "value_name", r->in.value_name);
28504                 ndr_print_uint32(ndr, "offered", r->in.offered);
28505                 ndr->depth--;
28506         }
28507         if (flags & NDR_OUT) {
28508                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28509                 ndr->depth++;
28510                 ndr_print_ptr(ndr, "type", r->out.type);
28511                 ndr->depth++;
28512                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28513                 ndr->depth--;
28514                 ndr_print_ptr(ndr, "data", r->out.data);
28515                 ndr->depth++;
28516                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
28517                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
28518                 ndr->depth--;
28519                 ndr_print_ptr(ndr, "needed", r->out.needed);
28520                 ndr->depth++;
28521                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28522                 ndr->depth--;
28523                 ndr_print_WERROR(ndr, "result", r->out.result);
28524                 ndr->depth--;
28525         }
28526         ndr->depth--;
28527 }
28528
28529 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28530 {
28531         if (flags & NDR_IN) {
28532                 if (r->in.handle == NULL) {
28533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28534                 }
28535                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28536                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28537                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28538                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28539                 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));
28540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28541         }
28542         if (flags & NDR_OUT) {
28543                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28544                 if (r->out.needed == NULL) {
28545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28546                 }
28547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28548                 if (r->out.count == NULL) {
28549                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28550                 }
28551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28552                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28553         }
28554         return NDR_ERR_SUCCESS;
28555 }
28556
28557 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28558 {
28559         TALLOC_CTX *_mem_save_handle_0;
28560         TALLOC_CTX *_mem_save_needed_0;
28561         TALLOC_CTX *_mem_save_count_0;
28562         if (flags & NDR_IN) {
28563                 ZERO_STRUCT(r->out);
28564
28565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28566                         NDR_PULL_ALLOC(ndr, r->in.handle);
28567                 }
28568                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28569                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28570                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28572                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28573                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28574                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28575                         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));
28576                 }
28577                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28578                 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));
28579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28580                 NDR_PULL_ALLOC(ndr, r->out.needed);
28581                 ZERO_STRUCTP(r->out.needed);
28582                 NDR_PULL_ALLOC(ndr, r->out.count);
28583                 ZERO_STRUCTP(r->out.count);
28584         }
28585         if (flags & NDR_OUT) {
28586                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28588                         NDR_PULL_ALLOC(ndr, r->out.needed);
28589                 }
28590                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28591                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28595                         NDR_PULL_ALLOC(ndr, r->out.count);
28596                 }
28597                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28598                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28602         }
28603         return NDR_ERR_SUCCESS;
28604 }
28605
28606 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28607 {
28608         uint32_t cntr_info_0;
28609         if (flags & NDR_IN) {
28610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28611         }
28612         if (flags & NDR_OUT) {
28613                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28614                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28615                 }
28616                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28617                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28618                 }
28619         }
28620         return NDR_ERR_SUCCESS;
28621 }
28622
28623 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28624 {
28625         uint32_t cntr_info_0;
28626         TALLOC_CTX *_mem_save_info_0;
28627         if (flags & NDR_IN) {
28628                 ZERO_STRUCT(r->out);
28629
28630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28631         }
28632         if (flags & NDR_OUT) {
28633                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28634                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28635                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28636                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28637                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28638                 }
28639                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28640                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28641                 }
28642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28643         }
28644         return NDR_ERR_SUCCESS;
28645 }
28646
28647 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28648 {
28649         uint32_t cntr_info_2;
28650         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28651         ndr->depth++;
28652         if (flags & NDR_SET_VALUES) {
28653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28654         }
28655         if (flags & NDR_IN) {
28656                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28657                 ndr->depth++;
28658                 ndr_print_ptr(ndr, "handle", r->in.handle);
28659                 ndr->depth++;
28660                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28661                 ndr->depth--;
28662                 ndr_print_string(ndr, "key_name", r->in.key_name);
28663                 ndr_print_uint32(ndr, "offered", r->in.offered);
28664                 ndr->depth--;
28665         }
28666         if (flags & NDR_OUT) {
28667                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28668                 ndr->depth++;
28669                 ndr_print_ptr(ndr, "count", r->out.count);
28670                 ndr->depth++;
28671                 ndr_print_uint32(ndr, "count", *r->out.count);
28672                 ndr->depth--;
28673                 ndr_print_ptr(ndr, "info", r->out.info);
28674                 ndr->depth++;
28675                 ndr_print_ptr(ndr, "info", *r->out.info);
28676                 ndr->depth++;
28677                 if (*r->out.info) {
28678                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28679                         ndr->depth++;
28680                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28681                                 char *idx_2=NULL;
28682                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28683                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28684                                         free(idx_2);
28685                                 }
28686                         }
28687                         ndr->depth--;
28688                 }
28689                 ndr->depth--;
28690                 ndr->depth--;
28691                 ndr_print_ptr(ndr, "needed", r->out.needed);
28692                 ndr->depth++;
28693                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28694                 ndr->depth--;
28695                 ndr_print_WERROR(ndr, "result", r->out.result);
28696                 ndr->depth--;
28697         }
28698         ndr->depth--;
28699 }
28700
28701 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28702 {
28703         if (flags & NDR_IN) {
28704                 if (r->in.handle == NULL) {
28705                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28706                 }
28707                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28708                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28709                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28710                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28711                 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));
28712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28713         }
28714         if (flags & NDR_OUT) {
28715                 if (r->out._ndr_size == NULL) {
28716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28717                 }
28718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28719                 if (r->out.key_buffer == NULL) {
28720                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28721                 }
28722                 {
28723                         struct ndr_push *_ndr_key_buffer;
28724                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28725                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28726                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28727                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28728                 }
28729                 if (r->out.needed == NULL) {
28730                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28731                 }
28732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28733                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28734         }
28735         return NDR_ERR_SUCCESS;
28736 }
28737
28738 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28739 {
28740         TALLOC_CTX *_mem_save_handle_0;
28741         TALLOC_CTX *_mem_save__ndr_size_0;
28742         TALLOC_CTX *_mem_save_key_buffer_0;
28743         TALLOC_CTX *_mem_save_needed_0;
28744         if (flags & NDR_IN) {
28745                 ZERO_STRUCT(r->out);
28746
28747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28748                         NDR_PULL_ALLOC(ndr, r->in.handle);
28749                 }
28750                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28751                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28752                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28753                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28754                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28755                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28756                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28757                         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));
28758                 }
28759                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28760                 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));
28761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28762                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28763                 ZERO_STRUCTP(r->out._ndr_size);
28764                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28765                 ZERO_STRUCTP(r->out.key_buffer);
28766                 NDR_PULL_ALLOC(ndr, r->out.needed);
28767                 ZERO_STRUCTP(r->out.needed);
28768         }
28769         if (flags & NDR_OUT) {
28770                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28771                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28772                 }
28773                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
28774                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
28775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
28776                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
28777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28778                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28779                 }
28780                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28781                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28782                 {
28783                         struct ndr_pull *_ndr_key_buffer;
28784                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28785                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28786                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28787                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28788                 }
28789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28791                         NDR_PULL_ALLOC(ndr, r->out.needed);
28792                 }
28793                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28794                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28797                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28798         }
28799         return NDR_ERR_SUCCESS;
28800 }
28801
28802 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28803 {
28804         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28805         ndr->depth++;
28806         if (flags & NDR_SET_VALUES) {
28807                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28808         }
28809         if (flags & NDR_IN) {
28810                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28811                 ndr->depth++;
28812                 ndr_print_ptr(ndr, "handle", r->in.handle);
28813                 ndr->depth++;
28814                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28815                 ndr->depth--;
28816                 ndr_print_string(ndr, "key_name", r->in.key_name);
28817                 ndr_print_uint32(ndr, "offered", r->in.offered);
28818                 ndr->depth--;
28819         }
28820         if (flags & NDR_OUT) {
28821                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28822                 ndr->depth++;
28823                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
28824                 ndr->depth++;
28825                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
28826                 ndr->depth--;
28827                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28828                 ndr->depth++;
28829                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
28830                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
28831                 ndr->depth--;
28832                 ndr_print_ptr(ndr, "needed", r->out.needed);
28833                 ndr->depth++;
28834                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28835                 ndr->depth--;
28836                 ndr_print_WERROR(ndr, "result", r->out.result);
28837                 ndr->depth--;
28838         }
28839         ndr->depth--;
28840 }
28841
28842 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28843 {
28844         if (flags & NDR_IN) {
28845                 if (r->in.handle == NULL) {
28846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28847                 }
28848                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28849                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28850                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28851                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28852                 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));
28853                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28854                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28855                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28856                 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));
28857         }
28858         if (flags & NDR_OUT) {
28859                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28860         }
28861         return NDR_ERR_SUCCESS;
28862 }
28863
28864 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28865 {
28866         TALLOC_CTX *_mem_save_handle_0;
28867         if (flags & NDR_IN) {
28868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28869                         NDR_PULL_ALLOC(ndr, r->in.handle);
28870                 }
28871                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28872                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28873                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28874                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28875                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28876                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28877                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28878                         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));
28879                 }
28880                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28881                 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));
28882                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28883                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28884                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28885                         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));
28886                 }
28887                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28888                 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));
28889         }
28890         if (flags & NDR_OUT) {
28891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28892         }
28893         return NDR_ERR_SUCCESS;
28894 }
28895
28896 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28897 {
28898         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28899         ndr->depth++;
28900         if (flags & NDR_SET_VALUES) {
28901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28902         }
28903         if (flags & NDR_IN) {
28904                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28905                 ndr->depth++;
28906                 ndr_print_ptr(ndr, "handle", r->in.handle);
28907                 ndr->depth++;
28908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28909                 ndr->depth--;
28910                 ndr_print_string(ndr, "key_name", r->in.key_name);
28911                 ndr_print_string(ndr, "value_name", r->in.value_name);
28912                 ndr->depth--;
28913         }
28914         if (flags & NDR_OUT) {
28915                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28916                 ndr->depth++;
28917                 ndr_print_WERROR(ndr, "result", r->out.result);
28918                 ndr->depth--;
28919         }
28920         ndr->depth--;
28921 }
28922
28923 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28924 {
28925         if (flags & NDR_IN) {
28926                 if (r->in.handle == NULL) {
28927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28928                 }
28929                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28930                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28931                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28932                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28933                 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));
28934         }
28935         if (flags & NDR_OUT) {
28936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28937         }
28938         return NDR_ERR_SUCCESS;
28939 }
28940
28941 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28942 {
28943         TALLOC_CTX *_mem_save_handle_0;
28944         if (flags & NDR_IN) {
28945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28946                         NDR_PULL_ALLOC(ndr, r->in.handle);
28947                 }
28948                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28949                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28950                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28952                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28953                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28954                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28955                         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));
28956                 }
28957                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28958                 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));
28959         }
28960         if (flags & NDR_OUT) {
28961                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28962         }
28963         return NDR_ERR_SUCCESS;
28964 }
28965
28966 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28967 {
28968         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28969         ndr->depth++;
28970         if (flags & NDR_SET_VALUES) {
28971                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28972         }
28973         if (flags & NDR_IN) {
28974                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28975                 ndr->depth++;
28976                 ndr_print_ptr(ndr, "handle", r->in.handle);
28977                 ndr->depth++;
28978                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28979                 ndr->depth--;
28980                 ndr_print_string(ndr, "key_name", r->in.key_name);
28981                 ndr->depth--;
28982         }
28983         if (flags & NDR_OUT) {
28984                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28985                 ndr->depth++;
28986                 ndr_print_WERROR(ndr, "result", r->out.result);
28987                 ndr->depth--;
28988         }
28989         ndr->depth--;
28990 }
28991
28992 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28993 {
28994         if (flags & NDR_IN) {
28995         }
28996         if (flags & NDR_OUT) {
28997                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28998         }
28999         return NDR_ERR_SUCCESS;
29000 }
29001
29002 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
29003 {
29004         if (flags & NDR_IN) {
29005         }
29006         if (flags & NDR_OUT) {
29007                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29008         }
29009         return NDR_ERR_SUCCESS;
29010 }
29011
29012 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
29013 {
29014         ndr_print_struct(ndr, name, "spoolss_53");
29015         ndr->depth++;
29016         if (flags & NDR_SET_VALUES) {
29017                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29018         }
29019         if (flags & NDR_IN) {
29020                 ndr_print_struct(ndr, "in", "spoolss_53");
29021                 ndr->depth++;
29022                 ndr->depth--;
29023         }
29024         if (flags & NDR_OUT) {
29025                 ndr_print_struct(ndr, "out", "spoolss_53");
29026                 ndr->depth++;
29027                 ndr_print_WERROR(ndr, "result", r->out.result);
29028                 ndr->depth--;
29029         }
29030         ndr->depth--;
29031 }
29032
29033 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29034 {
29035         if (flags & NDR_IN) {
29036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
29037                 if (r->in.server) {
29038                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29041                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29042                 }
29043                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29044                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29045                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29046                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29047                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29048                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29049                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29050                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29051                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
29052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
29053         }
29054         if (flags & NDR_OUT) {
29055                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29056         }
29057         return NDR_ERR_SUCCESS;
29058 }
29059
29060 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
29061 {
29062         uint32_t _ptr_server;
29063         TALLOC_CTX *_mem_save_server_0;
29064         if (flags & NDR_IN) {
29065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
29066                 if (_ptr_server) {
29067                         NDR_PULL_ALLOC(ndr, r->in.server);
29068                 } else {
29069                         r->in.server = NULL;
29070                 }
29071                 if (r->in.server) {
29072                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
29073                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
29074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
29075                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
29076                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
29077                                 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));
29078                         }
29079                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
29080                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
29081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
29082                 }
29083                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29084                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29085                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29086                         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));
29087                 }
29088                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29089                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29090                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
29091                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
29092                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
29093                         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));
29094                 }
29095                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
29096                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
29097                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
29098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
29099         }
29100         if (flags & NDR_OUT) {
29101                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29102         }
29103         return NDR_ERR_SUCCESS;
29104 }
29105
29106 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29107 {
29108         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
29109         ndr->depth++;
29110         if (flags & NDR_SET_VALUES) {
29111                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29112         }
29113         if (flags & NDR_IN) {
29114                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
29115                 ndr->depth++;
29116                 ndr_print_ptr(ndr, "server", r->in.server);
29117                 ndr->depth++;
29118                 if (r->in.server) {
29119                         ndr_print_string(ndr, "server", r->in.server);
29120                 }
29121                 ndr->depth--;
29122                 ndr_print_string(ndr, "architecture", r->in.architecture);
29123                 ndr_print_string(ndr, "driver", r->in.driver);
29124                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
29125                 ndr_print_uint32(ndr, "version", r->in.version);
29126                 ndr->depth--;
29127         }
29128         if (flags & NDR_OUT) {
29129                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
29130                 ndr->depth++;
29131                 ndr_print_WERROR(ndr, "result", r->out.result);
29132                 ndr->depth--;
29133         }
29134         ndr->depth--;
29135 }
29136
29137 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
29138 {
29139         if (flags & NDR_IN) {
29140         }
29141         if (flags & NDR_OUT) {
29142                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29143         }
29144         return NDR_ERR_SUCCESS;
29145 }
29146
29147 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
29148 {
29149         if (flags & NDR_IN) {
29150         }
29151         if (flags & NDR_OUT) {
29152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29153         }
29154         return NDR_ERR_SUCCESS;
29155 }
29156
29157 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
29158 {
29159         ndr_print_struct(ndr, name, "spoolss_55");
29160         ndr->depth++;
29161         if (flags & NDR_SET_VALUES) {
29162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29163         }
29164         if (flags & NDR_IN) {
29165                 ndr_print_struct(ndr, "in", "spoolss_55");
29166                 ndr->depth++;
29167                 ndr->depth--;
29168         }
29169         if (flags & NDR_OUT) {
29170                 ndr_print_struct(ndr, "out", "spoolss_55");
29171                 ndr->depth++;
29172                 ndr_print_WERROR(ndr, "result", r->out.result);
29173                 ndr->depth--;
29174         }
29175         ndr->depth--;
29176 }
29177
29178 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
29179 {
29180         if (flags & NDR_IN) {
29181         }
29182         if (flags & NDR_OUT) {
29183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29184         }
29185         return NDR_ERR_SUCCESS;
29186 }
29187
29188 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
29189 {
29190         if (flags & NDR_IN) {
29191         }
29192         if (flags & NDR_OUT) {
29193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29194         }
29195         return NDR_ERR_SUCCESS;
29196 }
29197
29198 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
29199 {
29200         ndr_print_struct(ndr, name, "spoolss_56");
29201         ndr->depth++;
29202         if (flags & NDR_SET_VALUES) {
29203                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29204         }
29205         if (flags & NDR_IN) {
29206                 ndr_print_struct(ndr, "in", "spoolss_56");
29207                 ndr->depth++;
29208                 ndr->depth--;
29209         }
29210         if (flags & NDR_OUT) {
29211                 ndr_print_struct(ndr, "out", "spoolss_56");
29212                 ndr->depth++;
29213                 ndr_print_WERROR(ndr, "result", r->out.result);
29214                 ndr->depth--;
29215         }
29216         ndr->depth--;
29217 }
29218
29219 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
29220 {
29221         if (flags & NDR_IN) {
29222         }
29223         if (flags & NDR_OUT) {
29224                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29225         }
29226         return NDR_ERR_SUCCESS;
29227 }
29228
29229 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
29230 {
29231         if (flags & NDR_IN) {
29232         }
29233         if (flags & NDR_OUT) {
29234                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29235         }
29236         return NDR_ERR_SUCCESS;
29237 }
29238
29239 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
29240 {
29241         ndr_print_struct(ndr, name, "spoolss_57");
29242         ndr->depth++;
29243         if (flags & NDR_SET_VALUES) {
29244                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29245         }
29246         if (flags & NDR_IN) {
29247                 ndr_print_struct(ndr, "in", "spoolss_57");
29248                 ndr->depth++;
29249                 ndr->depth--;
29250         }
29251         if (flags & NDR_OUT) {
29252                 ndr_print_struct(ndr, "out", "spoolss_57");
29253                 ndr->depth++;
29254                 ndr_print_WERROR(ndr, "result", r->out.result);
29255                 ndr->depth--;
29256         }
29257         ndr->depth--;
29258 }
29259
29260 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
29261 {
29262         if (flags & NDR_IN) {
29263                 if (r->in.handle == NULL) {
29264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29265                 }
29266                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29267                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29268                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29269                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29270                 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));
29271                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
29272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
29273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
29274                 if (r->in.status_code == NULL) {
29275                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29276                 }
29277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
29278         }
29279         if (flags & NDR_OUT) {
29280                 if (r->out.out_data == NULL) {
29281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29282                 }
29283                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
29284                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
29285                 if (r->out.needed == NULL) {
29286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29287                 }
29288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
29289                 if (r->out.status_code == NULL) {
29290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29291                 }
29292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
29293                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29294         }
29295         return NDR_ERR_SUCCESS;
29296 }
29297
29298 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
29299 {
29300         TALLOC_CTX *_mem_save_handle_0;
29301         TALLOC_CTX *_mem_save_needed_0;
29302         TALLOC_CTX *_mem_save_status_code_0;
29303         if (flags & NDR_IN) {
29304                 ZERO_STRUCT(r->out);
29305
29306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29307                         NDR_PULL_ALLOC(ndr, r->in.handle);
29308                 }
29309                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29310                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29311                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29312                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29313                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
29314                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
29315                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
29316                         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));
29317                 }
29318                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
29319                 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));
29320                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
29321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
29322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
29323                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29324                         NDR_PULL_ALLOC(ndr, r->in.status_code);
29325                 }
29326                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29327                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
29328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
29329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29330                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
29331                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
29332                 NDR_PULL_ALLOC(ndr, r->out.needed);
29333                 ZERO_STRUCTP(r->out.needed);
29334                 NDR_PULL_ALLOC(ndr, r->out.status_code);
29335                 *r->out.status_code = *r->in.status_code;
29336         }
29337         if (flags & NDR_OUT) {
29338                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
29339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29340                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
29341                 }
29342                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
29343                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29344                         NDR_PULL_ALLOC(ndr, r->out.needed);
29345                 }
29346                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29347                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29350                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29351                         NDR_PULL_ALLOC(ndr, r->out.status_code);
29352                 }
29353                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29354                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
29355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
29356                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29357                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29358                 if (r->out.out_data) {
29359                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
29360                 }
29361         }
29362         return NDR_ERR_SUCCESS;
29363 }
29364
29365 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
29366 {
29367         ndr_print_struct(ndr, name, "spoolss_XcvData");
29368         ndr->depth++;
29369         if (flags & NDR_SET_VALUES) {
29370                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29371         }
29372         if (flags & NDR_IN) {
29373                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
29374                 ndr->depth++;
29375                 ndr_print_ptr(ndr, "handle", r->in.handle);
29376                 ndr->depth++;
29377                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29378                 ndr->depth--;
29379                 ndr_print_string(ndr, "function_name", r->in.function_name);
29380                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
29381                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
29382                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
29383                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
29384                 ndr->depth++;
29385                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
29386                 ndr->depth--;
29387                 ndr->depth--;
29388         }
29389         if (flags & NDR_OUT) {
29390                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
29391                 ndr->depth++;
29392                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
29393                 ndr->depth++;
29394                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
29395                 ndr->depth--;
29396                 ndr_print_ptr(ndr, "needed", r->out.needed);
29397                 ndr->depth++;
29398                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29399                 ndr->depth--;
29400                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
29401                 ndr->depth++;
29402                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
29403                 ndr->depth--;
29404                 ndr_print_WERROR(ndr, "result", r->out.result);
29405                 ndr->depth--;
29406         }
29407         ndr->depth--;
29408 }
29409
29410 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
29411 {
29412         if (flags & NDR_IN) {
29413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29414                 if (r->in.servername) {
29415                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29418                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29419                 }
29420                 if (r->in.info_ctr == NULL) {
29421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29422                 }
29423                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29424                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
29425         }
29426         if (flags & NDR_OUT) {
29427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29428         }
29429         return NDR_ERR_SUCCESS;
29430 }
29431
29432 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
29433 {
29434         uint32_t _ptr_servername;
29435         TALLOC_CTX *_mem_save_servername_0;
29436         TALLOC_CTX *_mem_save_info_ctr_0;
29437         if (flags & NDR_IN) {
29438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29439                 if (_ptr_servername) {
29440                         NDR_PULL_ALLOC(ndr, r->in.servername);
29441                 } else {
29442                         r->in.servername = NULL;
29443                 }
29444                 if (r->in.servername) {
29445                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29446                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29449                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29450                                 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));
29451                         }
29452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29455                 }
29456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29457                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
29458                 }
29459                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
29460                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
29461                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
29463                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
29464         }
29465         if (flags & NDR_OUT) {
29466                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29467         }
29468         return NDR_ERR_SUCCESS;
29469 }
29470
29471 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
29472 {
29473         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
29474         ndr->depth++;
29475         if (flags & NDR_SET_VALUES) {
29476                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29477         }
29478         if (flags & NDR_IN) {
29479                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29480                 ndr->depth++;
29481                 ndr_print_ptr(ndr, "servername", r->in.servername);
29482                 ndr->depth++;
29483                 if (r->in.servername) {
29484                         ndr_print_string(ndr, "servername", r->in.servername);
29485                 }
29486                 ndr->depth--;
29487                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29488                 ndr->depth++;
29489                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29490                 ndr->depth--;
29491                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29492                 ndr->depth--;
29493         }
29494         if (flags & NDR_OUT) {
29495                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29496                 ndr->depth++;
29497                 ndr_print_WERROR(ndr, "result", r->out.result);
29498                 ndr->depth--;
29499         }
29500         ndr->depth--;
29501 }
29502
29503 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29504 {
29505         if (flags & NDR_IN) {
29506         }
29507         if (flags & NDR_OUT) {
29508                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29509         }
29510         return NDR_ERR_SUCCESS;
29511 }
29512
29513 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29514 {
29515         if (flags & NDR_IN) {
29516         }
29517         if (flags & NDR_OUT) {
29518                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29519         }
29520         return NDR_ERR_SUCCESS;
29521 }
29522
29523 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29524 {
29525         ndr_print_struct(ndr, name, "spoolss_5a");
29526         ndr->depth++;
29527         if (flags & NDR_SET_VALUES) {
29528                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29529         }
29530         if (flags & NDR_IN) {
29531                 ndr_print_struct(ndr, "in", "spoolss_5a");
29532                 ndr->depth++;
29533                 ndr->depth--;
29534         }
29535         if (flags & NDR_OUT) {
29536                 ndr_print_struct(ndr, "out", "spoolss_5a");
29537                 ndr->depth++;
29538                 ndr_print_WERROR(ndr, "result", r->out.result);
29539                 ndr->depth--;
29540         }
29541         ndr->depth--;
29542 }
29543
29544 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29545 {
29546         if (flags & NDR_IN) {
29547         }
29548         if (flags & NDR_OUT) {
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_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29555 {
29556         if (flags & NDR_IN) {
29557         }
29558         if (flags & NDR_OUT) {
29559                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29560         }
29561         return NDR_ERR_SUCCESS;
29562 }
29563
29564 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29565 {
29566         ndr_print_struct(ndr, name, "spoolss_5b");
29567         ndr->depth++;
29568         if (flags & NDR_SET_VALUES) {
29569                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29570         }
29571         if (flags & NDR_IN) {
29572                 ndr_print_struct(ndr, "in", "spoolss_5b");
29573                 ndr->depth++;
29574                 ndr->depth--;
29575         }
29576         if (flags & NDR_OUT) {
29577                 ndr_print_struct(ndr, "out", "spoolss_5b");
29578                 ndr->depth++;
29579                 ndr_print_WERROR(ndr, "result", r->out.result);
29580                 ndr->depth--;
29581         }
29582         ndr->depth--;
29583 }
29584
29585 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29586 {
29587         if (flags & NDR_IN) {
29588         }
29589         if (flags & NDR_OUT) {
29590                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29591         }
29592         return NDR_ERR_SUCCESS;
29593 }
29594
29595 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29596 {
29597         if (flags & NDR_IN) {
29598         }
29599         if (flags & NDR_OUT) {
29600                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29601         }
29602         return NDR_ERR_SUCCESS;
29603 }
29604
29605 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29606 {
29607         ndr_print_struct(ndr, name, "spoolss_5c");
29608         ndr->depth++;
29609         if (flags & NDR_SET_VALUES) {
29610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29611         }
29612         if (flags & NDR_IN) {
29613                 ndr_print_struct(ndr, "in", "spoolss_5c");
29614                 ndr->depth++;
29615                 ndr->depth--;
29616         }
29617         if (flags & NDR_OUT) {
29618                 ndr_print_struct(ndr, "out", "spoolss_5c");
29619                 ndr->depth++;
29620                 ndr_print_WERROR(ndr, "result", r->out.result);
29621                 ndr->depth--;
29622         }
29623         ndr->depth--;
29624 }
29625
29626 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29627 {
29628         if (flags & NDR_IN) {
29629         }
29630         if (flags & NDR_OUT) {
29631                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29632         }
29633         return NDR_ERR_SUCCESS;
29634 }
29635
29636 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29637 {
29638         if (flags & NDR_IN) {
29639         }
29640         if (flags & NDR_OUT) {
29641                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29642         }
29643         return NDR_ERR_SUCCESS;
29644 }
29645
29646 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29647 {
29648         ndr_print_struct(ndr, name, "spoolss_5d");
29649         ndr->depth++;
29650         if (flags & NDR_SET_VALUES) {
29651                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29652         }
29653         if (flags & NDR_IN) {
29654                 ndr_print_struct(ndr, "in", "spoolss_5d");
29655                 ndr->depth++;
29656                 ndr->depth--;
29657         }
29658         if (flags & NDR_OUT) {
29659                 ndr_print_struct(ndr, "out", "spoolss_5d");
29660                 ndr->depth++;
29661                 ndr_print_WERROR(ndr, "result", r->out.result);
29662                 ndr->depth--;
29663         }
29664         ndr->depth--;
29665 }
29666
29667 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29668 {
29669         if (flags & NDR_IN) {
29670         }
29671         if (flags & NDR_OUT) {
29672                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29673         }
29674         return NDR_ERR_SUCCESS;
29675 }
29676
29677 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29678 {
29679         if (flags & NDR_IN) {
29680         }
29681         if (flags & NDR_OUT) {
29682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29683         }
29684         return NDR_ERR_SUCCESS;
29685 }
29686
29687 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29688 {
29689         ndr_print_struct(ndr, name, "spoolss_5e");
29690         ndr->depth++;
29691         if (flags & NDR_SET_VALUES) {
29692                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29693         }
29694         if (flags & NDR_IN) {
29695                 ndr_print_struct(ndr, "in", "spoolss_5e");
29696                 ndr->depth++;
29697                 ndr->depth--;
29698         }
29699         if (flags & NDR_OUT) {
29700                 ndr_print_struct(ndr, "out", "spoolss_5e");
29701                 ndr->depth++;
29702                 ndr_print_WERROR(ndr, "result", r->out.result);
29703                 ndr->depth--;
29704         }
29705         ndr->depth--;
29706 }
29707
29708 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29709 {
29710         if (flags & NDR_IN) {
29711         }
29712         if (flags & NDR_OUT) {
29713                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29714         }
29715         return NDR_ERR_SUCCESS;
29716 }
29717
29718 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29719 {
29720         if (flags & NDR_IN) {
29721         }
29722         if (flags & NDR_OUT) {
29723                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29724         }
29725         return NDR_ERR_SUCCESS;
29726 }
29727
29728 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29729 {
29730         ndr_print_struct(ndr, name, "spoolss_5f");
29731         ndr->depth++;
29732         if (flags & NDR_SET_VALUES) {
29733                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29734         }
29735         if (flags & NDR_IN) {
29736                 ndr_print_struct(ndr, "in", "spoolss_5f");
29737                 ndr->depth++;
29738                 ndr->depth--;
29739         }
29740         if (flags & NDR_OUT) {
29741                 ndr_print_struct(ndr, "out", "spoolss_5f");
29742                 ndr->depth++;
29743                 ndr_print_WERROR(ndr, "result", r->out.result);
29744                 ndr->depth--;
29745         }
29746         ndr->depth--;
29747 }
29748
29749 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29750 {
29751         if (flags & NDR_IN) {
29752         }
29753         if (flags & NDR_OUT) {
29754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29755         }
29756         return NDR_ERR_SUCCESS;
29757 }
29758
29759 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29760 {
29761         if (flags & NDR_IN) {
29762         }
29763         if (flags & NDR_OUT) {
29764                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29765         }
29766         return NDR_ERR_SUCCESS;
29767 }
29768
29769 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29770 {
29771         ndr_print_struct(ndr, name, "spoolss_60");
29772         ndr->depth++;
29773         if (flags & NDR_SET_VALUES) {
29774                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29775         }
29776         if (flags & NDR_IN) {
29777                 ndr_print_struct(ndr, "in", "spoolss_60");
29778                 ndr->depth++;
29779                 ndr->depth--;
29780         }
29781         if (flags & NDR_OUT) {
29782                 ndr_print_struct(ndr, "out", "spoolss_60");
29783                 ndr->depth++;
29784                 ndr_print_WERROR(ndr, "result", r->out.result);
29785                 ndr->depth--;
29786         }
29787         ndr->depth--;
29788 }
29789
29790 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29791 {
29792         if (flags & NDR_IN) {
29793         }
29794         if (flags & NDR_OUT) {
29795                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29796         }
29797         return NDR_ERR_SUCCESS;
29798 }
29799
29800 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29801 {
29802         if (flags & NDR_IN) {
29803         }
29804         if (flags & NDR_OUT) {
29805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29806         }
29807         return NDR_ERR_SUCCESS;
29808 }
29809
29810 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29811 {
29812         ndr_print_struct(ndr, name, "spoolss_61");
29813         ndr->depth++;
29814         if (flags & NDR_SET_VALUES) {
29815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29816         }
29817         if (flags & NDR_IN) {
29818                 ndr_print_struct(ndr, "in", "spoolss_61");
29819                 ndr->depth++;
29820                 ndr->depth--;
29821         }
29822         if (flags & NDR_OUT) {
29823                 ndr_print_struct(ndr, "out", "spoolss_61");
29824                 ndr->depth++;
29825                 ndr_print_WERROR(ndr, "result", r->out.result);
29826                 ndr->depth--;
29827         }
29828         ndr->depth--;
29829 }
29830
29831 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29832 {
29833         if (flags & NDR_IN) {
29834         }
29835         if (flags & NDR_OUT) {
29836                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29837         }
29838         return NDR_ERR_SUCCESS;
29839 }
29840
29841 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29842 {
29843         if (flags & NDR_IN) {
29844         }
29845         if (flags & NDR_OUT) {
29846                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29847         }
29848         return NDR_ERR_SUCCESS;
29849 }
29850
29851 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29852 {
29853         ndr_print_struct(ndr, name, "spoolss_62");
29854         ndr->depth++;
29855         if (flags & NDR_SET_VALUES) {
29856                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29857         }
29858         if (flags & NDR_IN) {
29859                 ndr_print_struct(ndr, "in", "spoolss_62");
29860                 ndr->depth++;
29861                 ndr->depth--;
29862         }
29863         if (flags & NDR_OUT) {
29864                 ndr_print_struct(ndr, "out", "spoolss_62");
29865                 ndr->depth++;
29866                 ndr_print_WERROR(ndr, "result", r->out.result);
29867                 ndr->depth--;
29868         }
29869         ndr->depth--;
29870 }
29871
29872 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29873 {
29874         if (flags & NDR_IN) {
29875         }
29876         if (flags & NDR_OUT) {
29877                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29878         }
29879         return NDR_ERR_SUCCESS;
29880 }
29881
29882 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29883 {
29884         if (flags & NDR_IN) {
29885         }
29886         if (flags & NDR_OUT) {
29887                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29888         }
29889         return NDR_ERR_SUCCESS;
29890 }
29891
29892 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29893 {
29894         ndr_print_struct(ndr, name, "spoolss_63");
29895         ndr->depth++;
29896         if (flags & NDR_SET_VALUES) {
29897                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29898         }
29899         if (flags & NDR_IN) {
29900                 ndr_print_struct(ndr, "in", "spoolss_63");
29901                 ndr->depth++;
29902                 ndr->depth--;
29903         }
29904         if (flags & NDR_OUT) {
29905                 ndr_print_struct(ndr, "out", "spoolss_63");
29906                 ndr->depth++;
29907                 ndr_print_WERROR(ndr, "result", r->out.result);
29908                 ndr->depth--;
29909         }
29910         ndr->depth--;
29911 }
29912
29913 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29914 {
29915         if (flags & NDR_IN) {
29916         }
29917         if (flags & NDR_OUT) {
29918                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29919         }
29920         return NDR_ERR_SUCCESS;
29921 }
29922
29923 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29924 {
29925         if (flags & NDR_IN) {
29926         }
29927         if (flags & NDR_OUT) {
29928                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29929         }
29930         return NDR_ERR_SUCCESS;
29931 }
29932
29933 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29934 {
29935         ndr_print_struct(ndr, name, "spoolss_64");
29936         ndr->depth++;
29937         if (flags & NDR_SET_VALUES) {
29938                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29939         }
29940         if (flags & NDR_IN) {
29941                 ndr_print_struct(ndr, "in", "spoolss_64");
29942                 ndr->depth++;
29943                 ndr->depth--;
29944         }
29945         if (flags & NDR_OUT) {
29946                 ndr_print_struct(ndr, "out", "spoolss_64");
29947                 ndr->depth++;
29948                 ndr_print_WERROR(ndr, "result", r->out.result);
29949                 ndr->depth--;
29950         }
29951         ndr->depth--;
29952 }
29953
29954 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29955 {
29956         if (flags & NDR_IN) {
29957         }
29958         if (flags & NDR_OUT) {
29959                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29960         }
29961         return NDR_ERR_SUCCESS;
29962 }
29963
29964 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29965 {
29966         if (flags & NDR_IN) {
29967         }
29968         if (flags & NDR_OUT) {
29969                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29970         }
29971         return NDR_ERR_SUCCESS;
29972 }
29973
29974 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29975 {
29976         ndr_print_struct(ndr, name, "spoolss_65");
29977         ndr->depth++;
29978         if (flags & NDR_SET_VALUES) {
29979                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29980         }
29981         if (flags & NDR_IN) {
29982                 ndr_print_struct(ndr, "in", "spoolss_65");
29983                 ndr->depth++;
29984                 ndr->depth--;
29985         }
29986         if (flags & NDR_OUT) {
29987                 ndr_print_struct(ndr, "out", "spoolss_65");
29988                 ndr->depth++;
29989                 ndr_print_WERROR(ndr, "result", r->out.result);
29990                 ndr->depth--;
29991         }
29992         ndr->depth--;
29993 }
29994
29995 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29996 {
29997         uint32_t cntr_core_printer_drivers_1;
29998         if (flags & NDR_IN) {
29999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30000                 if (r->in.servername) {
30001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30004                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30005                 }
30006                 if (r->in.architecture == NULL) {
30007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30008                 }
30009                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30010                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30011                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30012                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
30014                 if (r->in.core_driver_dependencies == NULL) {
30015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30016                 }
30017                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
30018                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
30019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30020         }
30021         if (flags & NDR_OUT) {
30022                 if (r->out.core_printer_drivers == NULL) {
30023                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30024                 }
30025                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30026                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
30027                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30028                 }
30029                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30030         }
30031         return NDR_ERR_SUCCESS;
30032 }
30033
30034 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
30035 {
30036         uint32_t _ptr_servername;
30037         uint32_t cntr_core_printer_drivers_1;
30038         TALLOC_CTX *_mem_save_servername_0;
30039         TALLOC_CTX *_mem_save_core_printer_drivers_1;
30040         if (flags & NDR_IN) {
30041                 ZERO_STRUCT(r->out);
30042
30043                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30044                 if (_ptr_servername) {
30045                         NDR_PULL_ALLOC(ndr, r->in.servername);
30046                 } else {
30047                         r->in.servername = NULL;
30048                 }
30049                 if (r->in.servername) {
30050                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30051                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30052                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30053                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30054                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30055                                 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));
30056                         }
30057                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30058                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30060                 }
30061                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30062                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30063                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30064                         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));
30065                 }
30066                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30067                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
30069                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
30070                 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));
30071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
30072                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
30073                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
30074                 if (r->in.core_driver_dependencies) {
30075                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
30076                 }
30077         }
30078         if (flags & NDR_OUT) {
30079                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
30080                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30081                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
30082                 }
30083                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
30084                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
30085                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
30086                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30087                 }
30088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
30089                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30090                 if (r->out.core_printer_drivers) {
30091                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
30092                 }
30093         }
30094         return NDR_ERR_SUCCESS;
30095 }
30096
30097 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
30098 {
30099         uint32_t cntr_core_printer_drivers_1;
30100         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
30101         ndr->depth++;
30102         if (flags & NDR_SET_VALUES) {
30103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30104         }
30105         if (flags & NDR_IN) {
30106                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
30107                 ndr->depth++;
30108                 ndr_print_ptr(ndr, "servername", r->in.servername);
30109                 ndr->depth++;
30110                 if (r->in.servername) {
30111                         ndr_print_string(ndr, "servername", r->in.servername);
30112                 }
30113                 ndr->depth--;
30114                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30115                 ndr->depth++;
30116                 ndr_print_string(ndr, "architecture", r->in.architecture);
30117                 ndr->depth--;
30118                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
30119                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30120                 ndr->depth++;
30121                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30122                 ndr->depth--;
30123                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
30124                 ndr->depth--;
30125         }
30126         if (flags & NDR_OUT) {
30127                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
30128                 ndr->depth++;
30129                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
30130                 ndr->depth++;
30131                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
30132                 ndr->depth++;
30133                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
30134                         char *idx_1=NULL;
30135                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
30136                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
30137                                 free(idx_1);
30138                         }
30139                 }
30140                 ndr->depth--;
30141                 ndr->depth--;
30142                 ndr_print_WERROR(ndr, "result", r->out.result);
30143                 ndr->depth--;
30144         }
30145         ndr->depth--;
30146 }
30147
30148 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
30149 {
30150         if (flags & NDR_IN) {
30151         }
30152         if (flags & NDR_OUT) {
30153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30154         }
30155         return NDR_ERR_SUCCESS;
30156 }
30157
30158 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
30159 {
30160         if (flags & NDR_IN) {
30161         }
30162         if (flags & NDR_OUT) {
30163                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30164         }
30165         return NDR_ERR_SUCCESS;
30166 }
30167
30168 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
30169 {
30170         ndr_print_struct(ndr, name, "spoolss_67");
30171         ndr->depth++;
30172         if (flags & NDR_SET_VALUES) {
30173                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30174         }
30175         if (flags & NDR_IN) {
30176                 ndr_print_struct(ndr, "in", "spoolss_67");
30177                 ndr->depth++;
30178                 ndr->depth--;
30179         }
30180         if (flags & NDR_OUT) {
30181                 ndr_print_struct(ndr, "out", "spoolss_67");
30182                 ndr->depth++;
30183                 ndr_print_WERROR(ndr, "result", r->out.result);
30184                 ndr->depth--;
30185         }
30186         ndr->depth--;
30187 }
30188
30189 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30190 {
30191         if (flags & NDR_IN) {
30192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30193                 if (r->in.servername) {
30194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30198                 }
30199                 if (r->in.architecture == NULL) {
30200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30201                 }
30202                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30203                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30204                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30205                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
30207                 if (r->in.language) {
30208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30212                 }
30213                 if (r->in.package_id == NULL) {
30214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30215                 }
30216                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30217                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30218                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30219                 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));
30220                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
30221                 if (r->in.driver_package_cab) {
30222                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30223                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30224                 }
30225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30226         }
30227         if (flags & NDR_OUT) {
30228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
30229                 if (r->out.driver_package_cab) {
30230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30231                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30232                 }
30233                 if (r->out.required == NULL) {
30234                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30235                 }
30236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
30237                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30238         }
30239         return NDR_ERR_SUCCESS;
30240 }
30241
30242 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
30243 {
30244         uint32_t _ptr_servername;
30245         uint32_t _ptr_language;
30246         uint32_t _ptr_driver_package_cab;
30247         TALLOC_CTX *_mem_save_servername_0;
30248         TALLOC_CTX *_mem_save_language_0;
30249         TALLOC_CTX *_mem_save_driver_package_cab_0;
30250         TALLOC_CTX *_mem_save_required_0;
30251         if (flags & NDR_IN) {
30252                 ZERO_STRUCT(r->out);
30253
30254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30255                 if (_ptr_servername) {
30256                         NDR_PULL_ALLOC(ndr, r->in.servername);
30257                 } else {
30258                         r->in.servername = NULL;
30259                 }
30260                 if (r->in.servername) {
30261                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30262                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30263                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30264                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30265                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30266                                 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));
30267                         }
30268                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30271                 }
30272                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30273                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30274                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30275                         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));
30276                 }
30277                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30278                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
30280                 if (_ptr_language) {
30281                         NDR_PULL_ALLOC(ndr, r->in.language);
30282                 } else {
30283                         r->in.language = NULL;
30284                 }
30285                 if (r->in.language) {
30286                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
30287                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
30288                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
30289                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
30290                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
30291                                 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));
30292                         }
30293                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
30294                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
30295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
30296                 }
30297                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
30298                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
30299                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
30300                         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));
30301                 }
30302                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
30303                 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));
30304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30305                 if (_ptr_driver_package_cab) {
30306                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
30307                 } else {
30308                         r->in.driver_package_cab = NULL;
30309                 }
30310                 if (r->in.driver_package_cab) {
30311                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30312                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
30313                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
30314                         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));
30315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30316                 }
30317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
30318                 NDR_PULL_ALLOC(ndr, r->out.required);
30319                 ZERO_STRUCTP(r->out.required);
30320                 if (r->in.driver_package_cab) {
30321                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
30322                 }
30323         }
30324         if (flags & NDR_OUT) {
30325                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30326                 if (_ptr_driver_package_cab) {
30327                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
30328                 } else {
30329                         r->out.driver_package_cab = NULL;
30330                 }
30331                 if (r->out.driver_package_cab) {
30332                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30333                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
30334                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
30335                         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));
30336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30337                 }
30338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30339                         NDR_PULL_ALLOC(ndr, r->out.required);
30340                 }
30341                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
30342                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
30343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
30344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
30345                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30346                 if (r->out.driver_package_cab) {
30347                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
30348                 }
30349         }
30350         return NDR_ERR_SUCCESS;
30351 }
30352
30353 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30354 {
30355         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
30356         ndr->depth++;
30357         if (flags & NDR_SET_VALUES) {
30358                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30359         }
30360         if (flags & NDR_IN) {
30361                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
30362                 ndr->depth++;
30363                 ndr_print_ptr(ndr, "servername", r->in.servername);
30364                 ndr->depth++;
30365                 if (r->in.servername) {
30366                         ndr_print_string(ndr, "servername", r->in.servername);
30367                 }
30368                 ndr->depth--;
30369                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30370                 ndr->depth++;
30371                 ndr_print_string(ndr, "architecture", r->in.architecture);
30372                 ndr->depth--;
30373                 ndr_print_ptr(ndr, "language", r->in.language);
30374                 ndr->depth++;
30375                 if (r->in.language) {
30376                         ndr_print_string(ndr, "language", r->in.language);
30377                 }
30378                 ndr->depth--;
30379                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
30380                 ndr->depth++;
30381                 ndr_print_string(ndr, "package_id", r->in.package_id);
30382                 ndr->depth--;
30383                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
30384                 ndr->depth++;
30385                 if (r->in.driver_package_cab) {
30386                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
30387                 }
30388                 ndr->depth--;
30389                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
30390                 ndr->depth--;
30391         }
30392         if (flags & NDR_OUT) {
30393                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
30394                 ndr->depth++;
30395                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
30396                 ndr->depth++;
30397                 if (r->out.driver_package_cab) {
30398                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
30399                 }
30400                 ndr->depth--;
30401                 ndr_print_ptr(ndr, "required", r->out.required);
30402                 ndr->depth++;
30403                 ndr_print_uint32(ndr, "required", *r->out.required);
30404                 ndr->depth--;
30405                 ndr_print_WERROR(ndr, "result", r->out.result);
30406                 ndr->depth--;
30407         }
30408         ndr->depth--;
30409 }
30410
30411 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
30412 {
30413         if (flags & NDR_IN) {
30414         }
30415         if (flags & NDR_OUT) {
30416                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30417         }
30418         return NDR_ERR_SUCCESS;
30419 }
30420
30421 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
30422 {
30423         if (flags & NDR_IN) {
30424         }
30425         if (flags & NDR_OUT) {
30426                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30427         }
30428         return NDR_ERR_SUCCESS;
30429 }
30430
30431 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
30432 {
30433         ndr_print_struct(ndr, name, "spoolss_69");
30434         ndr->depth++;
30435         if (flags & NDR_SET_VALUES) {
30436                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30437         }
30438         if (flags & NDR_IN) {
30439                 ndr_print_struct(ndr, "in", "spoolss_69");
30440                 ndr->depth++;
30441                 ndr->depth--;
30442         }
30443         if (flags & NDR_OUT) {
30444                 ndr_print_struct(ndr, "out", "spoolss_69");
30445                 ndr->depth++;
30446                 ndr_print_WERROR(ndr, "result", r->out.result);
30447                 ndr->depth--;
30448         }
30449         ndr->depth--;
30450 }
30451
30452 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
30453 {
30454         if (flags & NDR_IN) {
30455         }
30456         if (flags & NDR_OUT) {
30457                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30458         }
30459         return NDR_ERR_SUCCESS;
30460 }
30461
30462 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
30463 {
30464         if (flags & NDR_IN) {
30465         }
30466         if (flags & NDR_OUT) {
30467                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30468         }
30469         return NDR_ERR_SUCCESS;
30470 }
30471
30472 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
30473 {
30474         ndr_print_struct(ndr, name, "spoolss_6a");
30475         ndr->depth++;
30476         if (flags & NDR_SET_VALUES) {
30477                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30478         }
30479         if (flags & NDR_IN) {
30480                 ndr_print_struct(ndr, "in", "spoolss_6a");
30481                 ndr->depth++;
30482                 ndr->depth--;
30483         }
30484         if (flags & NDR_OUT) {
30485                 ndr_print_struct(ndr, "out", "spoolss_6a");
30486                 ndr->depth++;
30487                 ndr_print_WERROR(ndr, "result", r->out.result);
30488                 ndr->depth--;
30489         }
30490         ndr->depth--;
30491 }
30492
30493 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30494 {
30495         if (flags & NDR_IN) {
30496         }
30497         if (flags & NDR_OUT) {
30498                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30499         }
30500         return NDR_ERR_SUCCESS;
30501 }
30502
30503 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30504 {
30505         if (flags & NDR_IN) {
30506         }
30507         if (flags & NDR_OUT) {
30508                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30509         }
30510         return NDR_ERR_SUCCESS;
30511 }
30512
30513 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30514 {
30515         ndr_print_struct(ndr, name, "spoolss_6b");
30516         ndr->depth++;
30517         if (flags & NDR_SET_VALUES) {
30518                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30519         }
30520         if (flags & NDR_IN) {
30521                 ndr_print_struct(ndr, "in", "spoolss_6b");
30522                 ndr->depth++;
30523                 ndr->depth--;
30524         }
30525         if (flags & NDR_OUT) {
30526                 ndr_print_struct(ndr, "out", "spoolss_6b");
30527                 ndr->depth++;
30528                 ndr_print_WERROR(ndr, "result", r->out.result);
30529                 ndr->depth--;
30530         }
30531         ndr->depth--;
30532 }
30533
30534 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30535 {
30536         if (flags & NDR_IN) {
30537         }
30538         if (flags & NDR_OUT) {
30539                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30540         }
30541         return NDR_ERR_SUCCESS;
30542 }
30543
30544 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30545 {
30546         if (flags & NDR_IN) {
30547         }
30548         if (flags & NDR_OUT) {
30549                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30550         }
30551         return NDR_ERR_SUCCESS;
30552 }
30553
30554 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30555 {
30556         ndr_print_struct(ndr, name, "spoolss_6c");
30557         ndr->depth++;
30558         if (flags & NDR_SET_VALUES) {
30559                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30560         }
30561         if (flags & NDR_IN) {
30562                 ndr_print_struct(ndr, "in", "spoolss_6c");
30563                 ndr->depth++;
30564                 ndr->depth--;
30565         }
30566         if (flags & NDR_OUT) {
30567                 ndr_print_struct(ndr, "out", "spoolss_6c");
30568                 ndr->depth++;
30569                 ndr_print_WERROR(ndr, "result", r->out.result);
30570                 ndr->depth--;
30571         }
30572         ndr->depth--;
30573 }
30574
30575 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30576 {
30577         if (flags & NDR_IN) {
30578         }
30579         if (flags & NDR_OUT) {
30580                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30581         }
30582         return NDR_ERR_SUCCESS;
30583 }
30584
30585 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30586 {
30587         if (flags & NDR_IN) {
30588         }
30589         if (flags & NDR_OUT) {
30590                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30591         }
30592         return NDR_ERR_SUCCESS;
30593 }
30594
30595 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30596 {
30597         ndr_print_struct(ndr, name, "spoolss_6d");
30598         ndr->depth++;
30599         if (flags & NDR_SET_VALUES) {
30600                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30601         }
30602         if (flags & NDR_IN) {
30603                 ndr_print_struct(ndr, "in", "spoolss_6d");
30604                 ndr->depth++;
30605                 ndr->depth--;
30606         }
30607         if (flags & NDR_OUT) {
30608                 ndr_print_struct(ndr, "out", "spoolss_6d");
30609                 ndr->depth++;
30610                 ndr_print_WERROR(ndr, "result", r->out.result);
30611                 ndr->depth--;
30612         }
30613         ndr->depth--;
30614 }
30615
30616 static const struct ndr_interface_call spoolss_calls[] = {
30617         {
30618                 "spoolss_EnumPrinters",
30619                 sizeof(struct spoolss_EnumPrinters),
30620                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30622                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30623                 false,
30624         },
30625         {
30626                 "spoolss_OpenPrinter",
30627                 sizeof(struct spoolss_OpenPrinter),
30628                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30630                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30631                 false,
30632         },
30633         {
30634                 "spoolss_SetJob",
30635                 sizeof(struct spoolss_SetJob),
30636                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30638                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30639                 false,
30640         },
30641         {
30642                 "spoolss_GetJob",
30643                 sizeof(struct spoolss_GetJob),
30644                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30646                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30647                 false,
30648         },
30649         {
30650                 "spoolss_EnumJobs",
30651                 sizeof(struct spoolss_EnumJobs),
30652                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30654                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30655                 false,
30656         },
30657         {
30658                 "spoolss_AddPrinter",
30659                 sizeof(struct spoolss_AddPrinter),
30660                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30662                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30663                 false,
30664         },
30665         {
30666                 "spoolss_DeletePrinter",
30667                 sizeof(struct spoolss_DeletePrinter),
30668                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30670                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30671                 false,
30672         },
30673         {
30674                 "spoolss_SetPrinter",
30675                 sizeof(struct spoolss_SetPrinter),
30676                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30678                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30679                 false,
30680         },
30681         {
30682                 "spoolss_GetPrinter",
30683                 sizeof(struct spoolss_GetPrinter),
30684                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30686                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30687                 false,
30688         },
30689         {
30690                 "spoolss_AddPrinterDriver",
30691                 sizeof(struct spoolss_AddPrinterDriver),
30692                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30694                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30695                 false,
30696         },
30697         {
30698                 "spoolss_EnumPrinterDrivers",
30699                 sizeof(struct spoolss_EnumPrinterDrivers),
30700                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30702                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30703                 false,
30704         },
30705         {
30706                 "spoolss_GetPrinterDriver",
30707                 sizeof(struct spoolss_GetPrinterDriver),
30708                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30710                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30711                 false,
30712         },
30713         {
30714                 "spoolss_GetPrinterDriverDirectory",
30715                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30716                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30718                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30719                 false,
30720         },
30721         {
30722                 "spoolss_DeletePrinterDriver",
30723                 sizeof(struct spoolss_DeletePrinterDriver),
30724                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30726                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30727                 false,
30728         },
30729         {
30730                 "spoolss_AddPrintProcessor",
30731                 sizeof(struct spoolss_AddPrintProcessor),
30732                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30734                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30735                 false,
30736         },
30737         {
30738                 "spoolss_EnumPrintProcessors",
30739                 sizeof(struct spoolss_EnumPrintProcessors),
30740                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30742                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30743                 false,
30744         },
30745         {
30746                 "spoolss_GetPrintProcessorDirectory",
30747                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30748                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30750                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30751                 false,
30752         },
30753         {
30754                 "spoolss_StartDocPrinter",
30755                 sizeof(struct spoolss_StartDocPrinter),
30756                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30758                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30759                 false,
30760         },
30761         {
30762                 "spoolss_StartPagePrinter",
30763                 sizeof(struct spoolss_StartPagePrinter),
30764                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30766                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30767                 false,
30768         },
30769         {
30770                 "spoolss_WritePrinter",
30771                 sizeof(struct spoolss_WritePrinter),
30772                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30774                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30775                 false,
30776         },
30777         {
30778                 "spoolss_EndPagePrinter",
30779                 sizeof(struct spoolss_EndPagePrinter),
30780                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30782                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30783                 false,
30784         },
30785         {
30786                 "spoolss_AbortPrinter",
30787                 sizeof(struct spoolss_AbortPrinter),
30788                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30790                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30791                 false,
30792         },
30793         {
30794                 "spoolss_ReadPrinter",
30795                 sizeof(struct spoolss_ReadPrinter),
30796                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30798                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30799                 false,
30800         },
30801         {
30802                 "spoolss_EndDocPrinter",
30803                 sizeof(struct spoolss_EndDocPrinter),
30804                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30806                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30807                 false,
30808         },
30809         {
30810                 "spoolss_AddJob",
30811                 sizeof(struct spoolss_AddJob),
30812                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30814                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
30815                 false,
30816         },
30817         {
30818                 "spoolss_ScheduleJob",
30819                 sizeof(struct spoolss_ScheduleJob),
30820                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30822                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30823                 false,
30824         },
30825         {
30826                 "spoolss_GetPrinterData",
30827                 sizeof(struct spoolss_GetPrinterData),
30828                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30830                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30831                 false,
30832         },
30833         {
30834                 "spoolss_SetPrinterData",
30835                 sizeof(struct spoolss_SetPrinterData),
30836                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30838                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30839                 false,
30840         },
30841         {
30842                 "spoolss_WaitForPrinterChange",
30843                 sizeof(struct spoolss_WaitForPrinterChange),
30844                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30846                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30847                 false,
30848         },
30849         {
30850                 "spoolss_ClosePrinter",
30851                 sizeof(struct spoolss_ClosePrinter),
30852                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30854                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30855                 false,
30856         },
30857         {
30858                 "spoolss_AddForm",
30859                 sizeof(struct spoolss_AddForm),
30860                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30862                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
30863                 false,
30864         },
30865         {
30866                 "spoolss_DeleteForm",
30867                 sizeof(struct spoolss_DeleteForm),
30868                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30870                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30871                 false,
30872         },
30873         {
30874                 "spoolss_GetForm",
30875                 sizeof(struct spoolss_GetForm),
30876                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30878                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
30879                 false,
30880         },
30881         {
30882                 "spoolss_SetForm",
30883                 sizeof(struct spoolss_SetForm),
30884                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30886                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
30887                 false,
30888         },
30889         {
30890                 "spoolss_EnumForms",
30891                 sizeof(struct spoolss_EnumForms),
30892                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30894                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30895                 false,
30896         },
30897         {
30898                 "spoolss_EnumPorts",
30899                 sizeof(struct spoolss_EnumPorts),
30900                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30902                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30903                 false,
30904         },
30905         {
30906                 "spoolss_EnumMonitors",
30907                 sizeof(struct spoolss_EnumMonitors),
30908                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30910                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30911                 false,
30912         },
30913         {
30914                 "spoolss_AddPort",
30915                 sizeof(struct spoolss_AddPort),
30916                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30918                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30919                 false,
30920         },
30921         {
30922                 "spoolss_ConfigurePort",
30923                 sizeof(struct spoolss_ConfigurePort),
30924                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30926                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30927                 false,
30928         },
30929         {
30930                 "spoolss_DeletePort",
30931                 sizeof(struct spoolss_DeletePort),
30932                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30934                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30935                 false,
30936         },
30937         {
30938                 "spoolss_CreatePrinterIC",
30939                 sizeof(struct spoolss_CreatePrinterIC),
30940                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30942                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30943                 false,
30944         },
30945         {
30946                 "spoolss_PlayGDIScriptOnPrinterIC",
30947                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30948                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30950                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30951                 false,
30952         },
30953         {
30954                 "spoolss_DeletePrinterIC",
30955                 sizeof(struct spoolss_DeletePrinterIC),
30956                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30958                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30959                 false,
30960         },
30961         {
30962                 "spoolss_AddPrinterConnection",
30963                 sizeof(struct spoolss_AddPrinterConnection),
30964                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30966                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30967                 false,
30968         },
30969         {
30970                 "spoolss_DeletePrinterConnection",
30971                 sizeof(struct spoolss_DeletePrinterConnection),
30972                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30974                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30975                 false,
30976         },
30977         {
30978                 "spoolss_PrinterMessageBox",
30979                 sizeof(struct spoolss_PrinterMessageBox),
30980                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30982                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30983                 false,
30984         },
30985         {
30986                 "spoolss_AddMonitor",
30987                 sizeof(struct spoolss_AddMonitor),
30988                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30990                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30991                 false,
30992         },
30993         {
30994                 "spoolss_DeleteMonitor",
30995                 sizeof(struct spoolss_DeleteMonitor),
30996                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30998                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30999                 false,
31000         },
31001         {
31002                 "spoolss_DeletePrintProcessor",
31003                 sizeof(struct spoolss_DeletePrintProcessor),
31004                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
31005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
31006                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
31007                 false,
31008         },
31009         {
31010                 "spoolss_AddPrintProvidor",
31011                 sizeof(struct spoolss_AddPrintProvidor),
31012                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
31013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
31014                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
31015                 false,
31016         },
31017         {
31018                 "spoolss_DeletePrintProvidor",
31019                 sizeof(struct spoolss_DeletePrintProvidor),
31020                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
31021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
31022                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
31023                 false,
31024         },
31025         {
31026                 "spoolss_EnumPrintProcDataTypes",
31027                 sizeof(struct spoolss_EnumPrintProcDataTypes),
31028                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
31029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
31030                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
31031                 false,
31032         },
31033         {
31034                 "spoolss_ResetPrinter",
31035                 sizeof(struct spoolss_ResetPrinter),
31036                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
31037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
31038                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
31039                 false,
31040         },
31041         {
31042                 "spoolss_GetPrinterDriver2",
31043                 sizeof(struct spoolss_GetPrinterDriver2),
31044                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
31045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
31046                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
31047                 false,
31048         },
31049         {
31050                 "spoolss_FindFirstPrinterChangeNotification",
31051                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
31052                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
31053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
31054                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
31055                 false,
31056         },
31057         {
31058                 "spoolss_FindNextPrinterChangeNotification",
31059                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
31060                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
31061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
31062                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
31063                 false,
31064         },
31065         {
31066                 "spoolss_FindClosePrinterNotify",
31067                 sizeof(struct spoolss_FindClosePrinterNotify),
31068                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
31069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
31070                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
31071                 false,
31072         },
31073         {
31074                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
31075                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
31076                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31078                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31079                 false,
31080         },
31081         {
31082                 "spoolss_ReplyOpenPrinter",
31083                 sizeof(struct spoolss_ReplyOpenPrinter),
31084                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
31085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
31086                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
31087                 false,
31088         },
31089         {
31090                 "spoolss_RouterReplyPrinter",
31091                 sizeof(struct spoolss_RouterReplyPrinter),
31092                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
31093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
31094                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
31095                 false,
31096         },
31097         {
31098                 "spoolss_ReplyClosePrinter",
31099                 sizeof(struct spoolss_ReplyClosePrinter),
31100                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
31101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
31102                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
31103                 false,
31104         },
31105         {
31106                 "spoolss_AddPortEx",
31107                 sizeof(struct spoolss_AddPortEx),
31108                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
31109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
31110                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
31111                 false,
31112         },
31113         {
31114                 "spoolss_RouterFindFirstPrinterChangeNotification",
31115                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
31116                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
31117                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
31118                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
31119                 false,
31120         },
31121         {
31122                 "spoolss_SpoolerInit",
31123                 sizeof(struct spoolss_SpoolerInit),
31124                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
31125                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
31126                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
31127                 false,
31128         },
31129         {
31130                 "spoolss_ResetPrinterEx",
31131                 sizeof(struct spoolss_ResetPrinterEx),
31132                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
31133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
31134                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
31135                 false,
31136         },
31137         {
31138                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
31139                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
31140                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31142                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31143                 false,
31144         },
31145         {
31146                 "spoolss_RouterReplyPrinterEx",
31147                 sizeof(struct spoolss_RouterReplyPrinterEx),
31148                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
31149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
31150                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
31151                 false,
31152         },
31153         {
31154                 "spoolss_RouterRefreshPrinterChangeNotify",
31155                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
31156                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
31157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
31158                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
31159                 false,
31160         },
31161         {
31162                 "spoolss_44",
31163                 sizeof(struct spoolss_44),
31164                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
31165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
31166                 (ndr_print_function_t) ndr_print_spoolss_44,
31167                 false,
31168         },
31169         {
31170                 "spoolss_OpenPrinterEx",
31171                 sizeof(struct spoolss_OpenPrinterEx),
31172                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
31173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
31174                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
31175                 false,
31176         },
31177         {
31178                 "spoolss_AddPrinterEx",
31179                 sizeof(struct spoolss_AddPrinterEx),
31180                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
31181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
31182                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
31183                 false,
31184         },
31185         {
31186                 "spoolss_47",
31187                 sizeof(struct spoolss_47),
31188                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
31189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
31190                 (ndr_print_function_t) ndr_print_spoolss_47,
31191                 false,
31192         },
31193         {
31194                 "spoolss_EnumPrinterData",
31195                 sizeof(struct spoolss_EnumPrinterData),
31196                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
31197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
31198                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
31199                 false,
31200         },
31201         {
31202                 "spoolss_DeletePrinterData",
31203                 sizeof(struct spoolss_DeletePrinterData),
31204                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
31205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
31206                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
31207                 false,
31208         },
31209         {
31210                 "spoolss_4a",
31211                 sizeof(struct spoolss_4a),
31212                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
31213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
31214                 (ndr_print_function_t) ndr_print_spoolss_4a,
31215                 false,
31216         },
31217         {
31218                 "spoolss_4b",
31219                 sizeof(struct spoolss_4b),
31220                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
31221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
31222                 (ndr_print_function_t) ndr_print_spoolss_4b,
31223                 false,
31224         },
31225         {
31226                 "spoolss_4c",
31227                 sizeof(struct spoolss_4c),
31228                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
31229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
31230                 (ndr_print_function_t) ndr_print_spoolss_4c,
31231                 false,
31232         },
31233         {
31234                 "spoolss_SetPrinterDataEx",
31235                 sizeof(struct spoolss_SetPrinterDataEx),
31236                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
31237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
31238                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
31239                 false,
31240         },
31241         {
31242                 "spoolss_GetPrinterDataEx",
31243                 sizeof(struct spoolss_GetPrinterDataEx),
31244                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
31245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
31246                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
31247                 false,
31248         },
31249         {
31250                 "spoolss_EnumPrinterDataEx",
31251                 sizeof(struct spoolss_EnumPrinterDataEx),
31252                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
31253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
31254                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
31255                 false,
31256         },
31257         {
31258                 "spoolss_EnumPrinterKey",
31259                 sizeof(struct spoolss_EnumPrinterKey),
31260                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
31261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
31262                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
31263                 false,
31264         },
31265         {
31266                 "spoolss_DeletePrinterDataEx",
31267                 sizeof(struct spoolss_DeletePrinterDataEx),
31268                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
31269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
31270                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
31271                 false,
31272         },
31273         {
31274                 "spoolss_DeletePrinterKey",
31275                 sizeof(struct spoolss_DeletePrinterKey),
31276                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
31277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
31278                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
31279                 false,
31280         },
31281         {
31282                 "spoolss_53",
31283                 sizeof(struct spoolss_53),
31284                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
31285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
31286                 (ndr_print_function_t) ndr_print_spoolss_53,
31287                 false,
31288         },
31289         {
31290                 "spoolss_DeletePrinterDriverEx",
31291                 sizeof(struct spoolss_DeletePrinterDriverEx),
31292                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
31293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
31294                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
31295                 false,
31296         },
31297         {
31298                 "spoolss_55",
31299                 sizeof(struct spoolss_55),
31300                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
31301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
31302                 (ndr_print_function_t) ndr_print_spoolss_55,
31303                 false,
31304         },
31305         {
31306                 "spoolss_56",
31307                 sizeof(struct spoolss_56),
31308                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
31309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
31310                 (ndr_print_function_t) ndr_print_spoolss_56,
31311                 false,
31312         },
31313         {
31314                 "spoolss_57",
31315                 sizeof(struct spoolss_57),
31316                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
31317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
31318                 (ndr_print_function_t) ndr_print_spoolss_57,
31319                 false,
31320         },
31321         {
31322                 "spoolss_XcvData",
31323                 sizeof(struct spoolss_XcvData),
31324                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
31325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
31326                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
31327                 false,
31328         },
31329         {
31330                 "spoolss_AddPrinterDriverEx",
31331                 sizeof(struct spoolss_AddPrinterDriverEx),
31332                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
31333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
31334                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
31335                 false,
31336         },
31337         {
31338                 "spoolss_5a",
31339                 sizeof(struct spoolss_5a),
31340                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
31341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
31342                 (ndr_print_function_t) ndr_print_spoolss_5a,
31343                 false,
31344         },
31345         {
31346                 "spoolss_5b",
31347                 sizeof(struct spoolss_5b),
31348                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
31349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
31350                 (ndr_print_function_t) ndr_print_spoolss_5b,
31351                 false,
31352         },
31353         {
31354                 "spoolss_5c",
31355                 sizeof(struct spoolss_5c),
31356                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
31357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
31358                 (ndr_print_function_t) ndr_print_spoolss_5c,
31359                 false,
31360         },
31361         {
31362                 "spoolss_5d",
31363                 sizeof(struct spoolss_5d),
31364                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
31365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
31366                 (ndr_print_function_t) ndr_print_spoolss_5d,
31367                 false,
31368         },
31369         {
31370                 "spoolss_5e",
31371                 sizeof(struct spoolss_5e),
31372                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
31373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
31374                 (ndr_print_function_t) ndr_print_spoolss_5e,
31375                 false,
31376         },
31377         {
31378                 "spoolss_5f",
31379                 sizeof(struct spoolss_5f),
31380                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
31381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
31382                 (ndr_print_function_t) ndr_print_spoolss_5f,
31383                 false,
31384         },
31385         {
31386                 "spoolss_60",
31387                 sizeof(struct spoolss_60),
31388                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
31389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
31390                 (ndr_print_function_t) ndr_print_spoolss_60,
31391                 false,
31392         },
31393         {
31394                 "spoolss_61",
31395                 sizeof(struct spoolss_61),
31396                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
31397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
31398                 (ndr_print_function_t) ndr_print_spoolss_61,
31399                 false,
31400         },
31401         {
31402                 "spoolss_62",
31403                 sizeof(struct spoolss_62),
31404                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
31405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
31406                 (ndr_print_function_t) ndr_print_spoolss_62,
31407                 false,
31408         },
31409         {
31410                 "spoolss_63",
31411                 sizeof(struct spoolss_63),
31412                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
31413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
31414                 (ndr_print_function_t) ndr_print_spoolss_63,
31415                 false,
31416         },
31417         {
31418                 "spoolss_64",
31419                 sizeof(struct spoolss_64),
31420                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
31421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
31422                 (ndr_print_function_t) ndr_print_spoolss_64,
31423                 false,
31424         },
31425         {
31426                 "spoolss_65",
31427                 sizeof(struct spoolss_65),
31428                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
31429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
31430                 (ndr_print_function_t) ndr_print_spoolss_65,
31431                 false,
31432         },
31433         {
31434                 "spoolss_GetCorePrinterDrivers",
31435                 sizeof(struct spoolss_GetCorePrinterDrivers),
31436                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
31437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
31438                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
31439                 false,
31440         },
31441         {
31442                 "spoolss_67",
31443                 sizeof(struct spoolss_67),
31444                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
31445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
31446                 (ndr_print_function_t) ndr_print_spoolss_67,
31447                 false,
31448         },
31449         {
31450                 "spoolss_GetPrinterDriverPackagePath",
31451                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
31452                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
31453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
31454                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
31455                 false,
31456         },
31457         {
31458                 "spoolss_69",
31459                 sizeof(struct spoolss_69),
31460                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
31461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
31462                 (ndr_print_function_t) ndr_print_spoolss_69,
31463                 false,
31464         },
31465         {
31466                 "spoolss_6a",
31467                 sizeof(struct spoolss_6a),
31468                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
31469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
31470                 (ndr_print_function_t) ndr_print_spoolss_6a,
31471                 false,
31472         },
31473         {
31474                 "spoolss_6b",
31475                 sizeof(struct spoolss_6b),
31476                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
31477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
31478                 (ndr_print_function_t) ndr_print_spoolss_6b,
31479                 false,
31480         },
31481         {
31482                 "spoolss_6c",
31483                 sizeof(struct spoolss_6c),
31484                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31486                 (ndr_print_function_t) ndr_print_spoolss_6c,
31487                 false,
31488         },
31489         {
31490                 "spoolss_6d",
31491                 sizeof(struct spoolss_6d),
31492                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31494                 (ndr_print_function_t) ndr_print_spoolss_6d,
31495                 false,
31496         },
31497         { NULL, 0, NULL, NULL, NULL, false }
31498 };
31499
31500 static const char * const spoolss_endpoint_strings[] = {
31501         "ncacn_np:[\\pipe\\spoolss]",
31502 };
31503
31504 static const struct ndr_interface_string_array spoolss_endpoints = {
31505         .count  = 1,
31506         .names  = spoolss_endpoint_strings
31507 };
31508
31509 static const char * const spoolss_authservice_strings[] = {
31510         "host",
31511 };
31512
31513 static const struct ndr_interface_string_array spoolss_authservices = {
31514         .count  = 1,
31515         .names  = spoolss_authservice_strings
31516 };
31517
31518
31519 const struct ndr_interface_table ndr_table_spoolss = {
31520         .name           = "spoolss",
31521         .syntax_id      = {
31522                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31523                 NDR_SPOOLSS_VERSION
31524         },
31525         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31526         .num_calls      = 110,
31527         .calls          = spoolss_calls,
31528         .endpoints      = &spoolss_endpoints,
31529         .authservices   = &spoolss_authservices
31530 };
31531