librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  48 {
  49         ndr_print_struct(ndr, name, "spoolss_Time");
  50         ndr->depth++;
  51         ndr_print_uint16(ndr, "year", r->year);
  52         ndr_print_uint16(ndr, "month", r->month);
  53         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  54         ndr_print_uint16(ndr, "day", r->day);
  55         ndr_print_uint16(ndr, "hour", r->hour);
  56         ndr_print_uint16(ndr, "minute", r->minute);
  57         ndr_print_uint16(ndr, "second", r->second);
  58         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  59         ndr->depth--;
  60 }
  61
  62 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  63 {
  64         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  65 }
  66
  67 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  68 {
  69         if (ndr_flags & NDR_SCALARS) {
  70                 NDR_CHECK(ndr_push_align(ndr, 5));
  71                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  72                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  73                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  74         }
  75         if (ndr_flags & NDR_BUFFERS) {
  76                 if (r->time) {
  77                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  78                 }
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  84 {
  85         uint32_t _ptr_time;
  86         TALLOC_CTX *_mem_save_time_0;
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_pull_align(ndr, 5));
  89                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  90                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  91                 if (_ptr_time) {
  92                         NDR_PULL_ALLOC(ndr, r->time);
  93                 } else {
  94                         r->time = NULL;
  95                 }
  96                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  97         }
  98         if (ndr_flags & NDR_BUFFERS) {
  99                 if (r->time) {
 100                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
 101                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
 102                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
 103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 110 {
 111         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 112         ndr->depth++;
 113         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 114         ndr_print_ptr(ndr, "time", r->time);
 115         ndr->depth++;
 116         if (r->time) {
 117                 ndr_print_spoolss_Time(ndr, "time", r->time);
 118         }
 119         ndr->depth--;
 120         ndr->depth--;
 121 }
 122
 123 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 124 {
 125         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 130 {
 131         uint16_t v;
 132         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 133         *r = v;
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 143                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 144                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 145         }
 146         ndr_print_enum(ndr, name, "ENUM", val, r);
 147 }
 148
 149 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 150 {
 151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 152         return NDR_ERR_SUCCESS;
 153 }
 154
 155 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 156 {
 157         uint32_t v;
 158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 159         *r = v;
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 164 {
 165         const char *val = NULL;
 166
 167         switch (r) {
 168                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 169                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 170                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 171                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 172                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 173         }
 174         ndr_print_enum(ndr, name, "ENUM", val, r);
 175 }
 176
 177 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 178 {
 179         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 184 {
 185         uint32_t v;
 186         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 187         *r = v;
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 192 {
 193         const char *val = NULL;
 194
 195         switch (r) {
 196                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 197                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 198                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 199         }
 200         ndr_print_enum(ndr, name, "ENUM", val, r);
 201 }
 202
 203 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 204 {
 205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 210 {
 211         uint32_t v;
 212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 213         *r = v;
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 218 {
 219         const char *val = NULL;
 220
 221         switch (r) {
 222                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 223                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 224                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 225                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 226                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 227         }
 228         ndr_print_enum(ndr, name, "ENUM", val, r);
 229 }
 230
 231 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 232 {
 233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 238 {
 239         uint32_t v;
 240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 241         *r = v;
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 246 {
 247         ndr_print_uint32(ndr, name, r);
 248         ndr->depth++;
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 274         ndr->depth--;
 275 }
 276
 277 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 278 {
 279         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 284 {
 285         uint32_t v;
 286         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 287         *r = v;
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 292 {
 293         ndr_print_uint32(ndr, name, r);
 294         ndr->depth++;
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 308         ndr->depth--;
 309 }
 310
 311 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 312 {
 313         if (ndr_flags & NDR_SCALARS) {
 314                 NDR_CHECK(ndr_push_align(ndr, 5));
 315                 {
 316                         uint32_t _flags_save_string = ndr->flags;
 317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 319                         ndr->flags = _flags_save_string;
 320                 }
 321                 {
 322                         uint32_t _flags_save_string = ndr->flags;
 323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 325                         ndr->flags = _flags_save_string;
 326                 }
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 330                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 340                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 342                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 346                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 349                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 354                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 355         }
 356         if (ndr_flags & NDR_BUFFERS) {
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 360                         if (r->printername) {
 361                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                         }
 364                         ndr->flags = _flags_save_string;
 365                 }
 366                 {
 367                         uint32_t _flags_save_string = ndr->flags;
 368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 369                         if (r->servername) {
 370                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 371                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 372                         }
 373                         ndr->flags = _flags_save_string;
 374                 }
 375         }
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 380 {
 381         uint32_t _ptr_printername;
 382         TALLOC_CTX *_mem_save_printername_0;
 383         uint32_t _ptr_servername;
 384         TALLOC_CTX *_mem_save_servername_0;
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_align(ndr, 5));
 387                 {
 388                         uint32_t _flags_save_string = ndr->flags;
 389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 391                         if (_ptr_printername) {
 392                                 NDR_PULL_ALLOC(ndr, r->printername);
 393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 394                         } else {
 395                                 r->printername = NULL;
 396                         }
 397                         ndr->flags = _flags_save_string;
 398                 }
 399                 {
 400                         uint32_t _flags_save_string = ndr->flags;
 401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 403                         if (_ptr_servername) {
 404                                 NDR_PULL_ALLOC(ndr, r->servername);
 405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 406                         } else {
 407                                 r->servername = NULL;
 408                         }
 409                         ndr->flags = _flags_save_string;
 410                 }
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 414                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 424                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 426                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 429                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 430                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 433                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 434                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 439         }
 440         if (ndr_flags & NDR_BUFFERS) {
 441                 {
 442                         uint32_t _flags_save_string = ndr->flags;
 443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 444                         if (r->printername) {
 445                                 uint32_t _relative_save_offset;
 446                                 _relative_save_offset = ndr->offset;
 447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 448                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 449                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 452                                 ndr->offset = _relative_save_offset;
 453                         }
 454                         ndr->flags = _flags_save_string;
 455                 }
 456                 {
 457                         uint32_t _flags_save_string = ndr->flags;
 458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 459                         if (r->servername) {
 460                                 uint32_t _relative_save_offset;
 461                                 _relative_save_offset = ndr->offset;
 462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 463                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 464                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 467                                 ndr->offset = _relative_save_offset;
 468                         }
 469                         ndr->flags = _flags_save_string;
 470                 }
 471         }
 472         return NDR_ERR_SUCCESS;
 473 }
 474
 475 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 476 {
 477         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 478         ndr->depth++;
 479         ndr_print_ptr(ndr, "printername", r->printername);
 480         ndr->depth++;
 481         if (r->printername) {
 482                 ndr_print_string(ndr, "printername", r->printername);
 483         }
 484         ndr->depth--;
 485         ndr_print_ptr(ndr, "servername", r->servername);
 486         ndr->depth++;
 487         if (r->servername) {
 488                 ndr_print_string(ndr, "servername", r->servername);
 489         }
 490         ndr->depth--;
 491         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 492         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 493         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 494         ndr_print_spoolss_Time(ndr, "time", &r->time);
 495         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 496         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 497         ndr_print_uint32(ndr, "version", r->version);
 498         ndr_print_uint32(ndr, "free_build", r->free_build);
 499         ndr_print_uint32(ndr, "spooling", r->spooling);
 500         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 501         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 502         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 503         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 504         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 505         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 506         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 507         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 508         ndr_print_uint32(ndr, "change_id", r->change_id);
 509         ndr_print_WERROR(ndr, "last_error", r->last_error);
 510         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 511         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 512         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 513         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 514         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 515         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 516         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 517         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 518         ndr->depth--;
 519 }
 520
 521 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 522 {
 523         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 524 }
 525
 526 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 527 {
 528         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 529         return NDR_ERR_SUCCESS;
 530 }
 531
 532 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 533 {
 534         uint32_t v;
 535         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 536         *r = v;
 537         return NDR_ERR_SUCCESS;
 538 }
 539
 540 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 541 {
 542         ndr_print_uint32(ndr, name, r);
 543         ndr->depth++;
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 572         ndr->depth--;
 573 }
 574
 575 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 576 {
 577         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 578         return NDR_ERR_SUCCESS;
 579 }
 580
 581 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 582 {
 583         uint16_t v;
 584         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 585         *r = v;
 586         return NDR_ERR_SUCCESS;
 587 }
 588
 589 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 590 {
 591         const char *val = NULL;
 592
 593         switch (r) {
 594                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 595                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 596                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 597         }
 598         ndr_print_enum(ndr, name, "ENUM", val, r);
 599 }
 600
 601 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 602 {
 603         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 604         return NDR_ERR_SUCCESS;
 605 }
 606
 607 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 608 {
 609         uint16_t v;
 610         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 611         *r = v;
 612         return NDR_ERR_SUCCESS;
 613 }
 614
 615 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 616 {
 617         const char *val = NULL;
 618
 619         switch (r) {
 620                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 621                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 622         }
 623         ndr_print_enum(ndr, name, "ENUM", val, r);
 624 }
 625
 626 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 627 {
 628         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 629         return NDR_ERR_SUCCESS;
 630 }
 631
 632 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 633 {
 634         uint16_t v;
 635         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 636         *r = v;
 637         return NDR_ERR_SUCCESS;
 638 }
 639
 640 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 641 {
 642         const char *val = NULL;
 643
 644         switch (r) {
 645                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 646                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 647                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 648                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 649                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 650                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 651                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 652                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 653                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 654                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 655                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 656                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 657                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 658                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 659                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 660                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 661                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 662                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 663                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 664                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 665                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 666                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 667                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 668                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 669                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 670                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 671                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 672                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 673                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 674                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 675                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 676                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 677                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 678                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 679                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 680                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 681                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 682                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 683                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 684                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 685                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 686                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 687                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 688                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 689                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 690                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 691                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 692                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 693                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 694                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 695                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 696                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 697                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 698                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 699                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 700                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 701                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 702                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 703                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 704                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 705                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 706                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 707                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 708                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 709                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 710                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 711                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 712                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 713                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 714                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 715                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 716                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 717                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 718                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 719                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 720                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 721                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 722                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 723                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 724                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 725                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 726                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 727                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 728                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 729                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 730                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 731                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 732                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 733                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 734                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 735                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 736         }
 737         ndr_print_enum(ndr, name, "ENUM", val, r);
 738 }
 739
 740 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 741 {
 742         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 743         return NDR_ERR_SUCCESS;
 744 }
 745
 746 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 747 {
 748         uint16_t v;
 749         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 750         *r = v;
 751         return NDR_ERR_SUCCESS;
 752 }
 753
 754 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 755 {
 756         const char *val = NULL;
 757
 758         switch (r) {
 759                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 760                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 761                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 762                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 763                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 764                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 765                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 766                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 767                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 768                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 769                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 770                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 771                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 772         }
 773         ndr_print_enum(ndr, name, "ENUM", val, r);
 774 }
 775
 776 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 777 {
 778         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 779         return NDR_ERR_SUCCESS;
 780 }
 781
 782 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 783 {
 784         uint16_t v;
 785         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 786         *r = v;
 787         return NDR_ERR_SUCCESS;
 788 }
 789
 790 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 791 {
 792         const char *val = NULL;
 793
 794         switch (r) {
 795                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 796                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 797                 case DMRES_LOW: val = "DMRES_LOW"; break;
 798                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 799         }
 800         ndr_print_enum(ndr, name, "ENUM", val, r);
 801 }
 802
 803 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 804 {
 805         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 806         return NDR_ERR_SUCCESS;
 807 }
 808
 809 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 810 {
 811         uint16_t v;
 812         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 813         *r = v;
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 818 {
 819         const char *val = NULL;
 820
 821         switch (r) {
 822                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 823                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 824         }
 825         ndr_print_enum(ndr, name, "ENUM", val, r);
 826 }
 827
 828 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 829 {
 830         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 831         return NDR_ERR_SUCCESS;
 832 }
 833
 834 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 835 {
 836         uint16_t v;
 837         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 838         *r = v;
 839         return NDR_ERR_SUCCESS;
 840 }
 841
 842 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 843 {
 844         const char *val = NULL;
 845
 846         switch (r) {
 847                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 848                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 849                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 850         }
 851         ndr_print_enum(ndr, name, "ENUM", val, r);
 852 }
 853
 854 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 855 {
 856         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 857         return NDR_ERR_SUCCESS;
 858 }
 859
 860 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 861 {
 862         uint16_t v;
 863         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 864         *r = v;
 865         return NDR_ERR_SUCCESS;
 866 }
 867
 868 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 869 {
 870         const char *val = NULL;
 871
 872         switch (r) {
 873                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 874                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 875                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 876                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 877         }
 878         ndr_print_enum(ndr, name, "ENUM", val, r);
 879 }
 880
 881 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 882 {
 883         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 884         return NDR_ERR_SUCCESS;
 885 }
 886
 887 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 888 {
 889         uint16_t v;
 890         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 891         *r = v;
 892         return NDR_ERR_SUCCESS;
 893 }
 894
 895 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 896 {
 897         const char *val = NULL;
 898
 899         switch (r) {
 900                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 901                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 902         }
 903         ndr_print_enum(ndr, name, "ENUM", val, r);
 904 }
 905
 906 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 907 {
 908         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 909         return NDR_ERR_SUCCESS;
 910 }
 911
 912 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 913 {
 914         uint32_t v;
 915         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 916         *r = v;
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 921 {
 922         const char *val = NULL;
 923
 924         switch (r) {
 925                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 926                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 927         }
 928         ndr_print_enum(ndr, name, "ENUM", val, r);
 929 }
 930
 931 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 932 {
 933         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 934         return NDR_ERR_SUCCESS;
 935 }
 936
 937 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 938 {
 939         uint32_t v;
 940         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 941         *r = v;
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 946 {
 947         const char *val = NULL;
 948
 949         switch (r) {
 950                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 951                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 952                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 953                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 954         }
 955         ndr_print_enum(ndr, name, "ENUM", val, r);
 956 }
 957
 958 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 959 {
 960         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 961         return NDR_ERR_SUCCESS;
 962 }
 963
 964 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 965 {
 966         uint32_t v;
 967         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 968         *r = v;
 969         return NDR_ERR_SUCCESS;
 970 }
 971
 972 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 973 {
 974         const char *val = NULL;
 975
 976         switch (r) {
 977                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 978                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 979                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 980                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 981         }
 982         ndr_print_enum(ndr, name, "ENUM", val, r);
 983 }
 984
 985 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 986 {
 987         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 988         return NDR_ERR_SUCCESS;
 989 }
 990
 991 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 992 {
 993         uint32_t v;
 994         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 995         *r = v;
 996         return NDR_ERR_SUCCESS;
 997 }
 998
 999 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1000 {
1001         const char *val = NULL;
1002
1003         switch (r) {
1004                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1005                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1006                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1007         }
1008         ndr_print_enum(ndr, name, "ENUM", val, r);
1009 }
1010
1011 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1012 {
1013         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1014         return NDR_ERR_SUCCESS;
1015 }
1016
1017 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1018 {
1019         uint32_t v;
1020         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1021         *r = v;
1022         return NDR_ERR_SUCCESS;
1023 }
1024
1025 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1026 {
1027         const char *val = NULL;
1028
1029         switch (r) {
1030                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1031                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1032                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1033                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1034                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1035                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1036                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1037                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1038                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1039                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1040         }
1041         ndr_print_enum(ndr, name, "ENUM", val, r);
1042 }
1043
1044 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1045 {
1046         if (ndr_flags & NDR_SCALARS) {
1047                 NDR_CHECK(ndr_push_align(ndr, 4));
1048                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1049                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1050                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1051                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1052                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1053                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1054                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1055                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1056                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1057                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1059                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1060                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1062                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1063                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1065                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1066                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1067                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1068                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1072                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1074                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1075                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1076                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1077                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1082                 {
1083                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1085                         {
1086                                 struct ndr_push *_ndr_driverextra_data;
1087                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1088                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1089                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1090                         }
1091                         ndr->flags = _flags_save_DATA_BLOB;
1092                 }
1093                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1094         }
1095         if (ndr_flags & NDR_BUFFERS) {
1096         }
1097         return NDR_ERR_SUCCESS;
1098 }
1099
1100 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1101 {
1102         if (ndr_flags & NDR_SCALARS) {
1103                 NDR_CHECK(ndr_pull_align(ndr, 4));
1104                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1105                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1106                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1107                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1108                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1109                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1110                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1112                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1113                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1115                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1116                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1118                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1119                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1121                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1122                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1123                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1124                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1128                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1130                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1131                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1132                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1133                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1138                 {
1139                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1141                         {
1142                                 struct ndr_pull *_ndr_driverextra_data;
1143                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1144                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1145                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1146                         }
1147                         ndr->flags = _flags_save_DATA_BLOB;
1148                 }
1149                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1150         }
1151         if (ndr_flags & NDR_BUFFERS) {
1152         }
1153         return NDR_ERR_SUCCESS;
1154 }
1155
1156 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1157 {
1158         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1159         ndr->depth++;
1160         ndr_print_string(ndr, "devicename", r->devicename);
1161         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1162         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1163         ndr_print_uint16(ndr, "size", r->size);
1164         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1165         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1166         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1167         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1168         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1169         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1170         ndr_print_uint16(ndr, "scale", r->scale);
1171         ndr_print_uint16(ndr, "copies", r->copies);
1172         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1173         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1174         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1175         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1176         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1177         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1178         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1179         ndr_print_string(ndr, "formname", r->formname);
1180         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1181         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1182         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1183         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1184         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1185         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1186         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1187         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1188         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1189         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1190         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1191         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1192         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1193         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1194         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1195         ndr->depth--;
1196 }
1197
1198 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1199 {
1200         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1201 }
1202
1203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1204 {
1205         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1206         return NDR_ERR_SUCCESS;
1207 }
1208
1209 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1210 {
1211         uint32_t v;
1212         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1213         *r = v;
1214         return NDR_ERR_SUCCESS;
1215 }
1216
1217 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1218 {
1219         ndr_print_uint32(ndr, name, r);
1220         ndr->depth++;
1221         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1222         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1223         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1224         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1225         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1226         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1240         ndr->depth--;
1241 }
1242
1243 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1244 {
1245         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1246         return NDR_ERR_SUCCESS;
1247 }
1248
1249 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1250 {
1251         uint32_t v;
1252         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1253         *r = v;
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1258 {
1259         ndr_print_uint32(ndr, name, r);
1260         ndr->depth++;
1261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1277         ndr->depth--;
1278 }
1279
1280 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1281 {
1282         if (ndr_flags & NDR_SCALARS) {
1283                 NDR_CHECK(ndr_push_align(ndr, 5));
1284                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1285                 {
1286                         uint32_t _flags_save_string = ndr->flags;
1287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1289                         ndr->flags = _flags_save_string;
1290                 }
1291                 {
1292                         uint32_t _flags_save_string = ndr->flags;
1293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1295                         ndr->flags = _flags_save_string;
1296                 }
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1301                         ndr->flags = _flags_save_string;
1302                 }
1303                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1304         }
1305         if (ndr_flags & NDR_BUFFERS) {
1306                 {
1307                         uint32_t _flags_save_string = ndr->flags;
1308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1309                         if (r->description) {
1310                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
1311                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1312                         }
1313                         ndr->flags = _flags_save_string;
1314                 }
1315                 {
1316                         uint32_t _flags_save_string = ndr->flags;
1317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1318                         if (r->name) {
1319                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
1320                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
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->comment) {
1328                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1329                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1330                         }
1331                         ndr->flags = _flags_save_string;
1332                 }
1333         }
1334         return NDR_ERR_SUCCESS;
1335 }
1336
1337 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1338 {
1339         uint32_t _ptr_description;
1340         TALLOC_CTX *_mem_save_description_0;
1341         uint32_t _ptr_name;
1342         TALLOC_CTX *_mem_save_name_0;
1343         uint32_t _ptr_comment;
1344         TALLOC_CTX *_mem_save_comment_0;
1345         if (ndr_flags & NDR_SCALARS) {
1346                 NDR_CHECK(ndr_pull_align(ndr, 5));
1347                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1352                         if (_ptr_description) {
1353                                 NDR_PULL_ALLOC(ndr, r->description);
1354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1355                         } else {
1356                                 r->description = NULL;
1357                         }
1358                         ndr->flags = _flags_save_string;
1359                 }
1360                 {
1361                         uint32_t _flags_save_string = ndr->flags;
1362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1363                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1364                         if (_ptr_name) {
1365                                 NDR_PULL_ALLOC(ndr, r->name);
1366                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1367                         } else {
1368                                 r->name = NULL;
1369                         }
1370                         ndr->flags = _flags_save_string;
1371                 }
1372                 {
1373                         uint32_t _flags_save_string = ndr->flags;
1374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1376                         if (_ptr_comment) {
1377                                 NDR_PULL_ALLOC(ndr, r->comment);
1378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1379                         } else {
1380                                 r->comment = NULL;
1381                         }
1382                         ndr->flags = _flags_save_string;
1383                 }
1384                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1385         }
1386         if (ndr_flags & NDR_BUFFERS) {
1387                 {
1388                         uint32_t _flags_save_string = ndr->flags;
1389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1390                         if (r->description) {
1391                                 uint32_t _relative_save_offset;
1392                                 _relative_save_offset = ndr->offset;
1393                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1394                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1395                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1396                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1397                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1398                                 ndr->offset = _relative_save_offset;
1399                         }
1400                         ndr->flags = _flags_save_string;
1401                 }
1402                 {
1403                         uint32_t _flags_save_string = ndr->flags;
1404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1405                         if (r->name) {
1406                                 uint32_t _relative_save_offset;
1407                                 _relative_save_offset = ndr->offset;
1408                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1409                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1410                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1411                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1412                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1413                                 ndr->offset = _relative_save_offset;
1414                         }
1415                         ndr->flags = _flags_save_string;
1416                 }
1417                 {
1418                         uint32_t _flags_save_string = ndr->flags;
1419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1420                         if (r->comment) {
1421                                 uint32_t _relative_save_offset;
1422                                 _relative_save_offset = ndr->offset;
1423                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1424                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1425                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1426                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1427                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1428                                 ndr->offset = _relative_save_offset;
1429                         }
1430                         ndr->flags = _flags_save_string;
1431                 }
1432         }
1433         return NDR_ERR_SUCCESS;
1434 }
1435
1436 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1437 {
1438         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1439         ndr->depth++;
1440         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1441         ndr_print_ptr(ndr, "description", r->description);
1442         ndr->depth++;
1443         if (r->description) {
1444                 ndr_print_string(ndr, "description", r->description);
1445         }
1446         ndr->depth--;
1447         ndr_print_ptr(ndr, "name", r->name);
1448         ndr->depth++;
1449         if (r->name) {
1450                 ndr_print_string(ndr, "name", r->name);
1451         }
1452         ndr->depth--;
1453         ndr_print_ptr(ndr, "comment", r->comment);
1454         ndr->depth++;
1455         if (r->comment) {
1456                 ndr_print_string(ndr, "comment", r->comment);
1457         }
1458         ndr->depth--;
1459         ndr->depth--;
1460 }
1461
1462 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1463 {
1464         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1465 }
1466
1467 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1468 {
1469         if (ndr_flags & NDR_SCALARS) {
1470                 NDR_CHECK(ndr_push_align(ndr, 5));
1471                 {
1472                         uint32_t _flags_save_string = ndr->flags;
1473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1474                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1475                         ndr->flags = _flags_save_string;
1476                 }
1477                 {
1478                         uint32_t _flags_save_string = ndr->flags;
1479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1481                         ndr->flags = _flags_save_string;
1482                 }
1483                 {
1484                         uint32_t _flags_save_string = ndr->flags;
1485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1487                         ndr->flags = _flags_save_string;
1488                 }
1489                 {
1490                         uint32_t _flags_save_string = ndr->flags;
1491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1493                         ndr->flags = _flags_save_string;
1494                 }
1495                 {
1496                         uint32_t _flags_save_string = ndr->flags;
1497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1499                         ndr->flags = _flags_save_string;
1500                 }
1501                 {
1502                         uint32_t _flags_save_string = ndr->flags;
1503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1505                         ndr->flags = _flags_save_string;
1506                 }
1507                 {
1508                         uint32_t _flags_save_string = ndr->flags;
1509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1511                         ndr->flags = _flags_save_string;
1512                 }
1513                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1514                 {
1515                         uint32_t _flags_save_string = ndr->flags;
1516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1518                         ndr->flags = _flags_save_string;
1519                 }
1520                 {
1521                         uint32_t _flags_save_string = ndr->flags;
1522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1524                         ndr->flags = _flags_save_string;
1525                 }
1526                 {
1527                         uint32_t _flags_save_string = ndr->flags;
1528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1530                         ndr->flags = _flags_save_string;
1531                 }
1532                 {
1533                         uint32_t _flags_save_string = ndr->flags;
1534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1536                         ndr->flags = _flags_save_string;
1537                 }
1538                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1539                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1544                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1547                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1548         }
1549         if (ndr_flags & NDR_BUFFERS) {
1550                 {
1551                         uint32_t _flags_save_string = ndr->flags;
1552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1553                         if (r->servername) {
1554                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1555                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1556                         }
1557                         ndr->flags = _flags_save_string;
1558                 }
1559                 {
1560                         uint32_t _flags_save_string = ndr->flags;
1561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1562                         if (r->printername) {
1563                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1564                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1565                         }
1566                         ndr->flags = _flags_save_string;
1567                 }
1568                 {
1569                         uint32_t _flags_save_string = ndr->flags;
1570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1571                         if (r->sharename) {
1572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1573                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
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                         if (r->portname) {
1581                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1582                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1583                         }
1584                         ndr->flags = _flags_save_string;
1585                 }
1586                 {
1587                         uint32_t _flags_save_string = ndr->flags;
1588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1589                         if (r->drivername) {
1590                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1591                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1592                         }
1593                         ndr->flags = _flags_save_string;
1594                 }
1595                 {
1596                         uint32_t _flags_save_string = ndr->flags;
1597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1598                         if (r->comment) {
1599                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1600                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1601                         }
1602                         ndr->flags = _flags_save_string;
1603                 }
1604                 {
1605                         uint32_t _flags_save_string = ndr->flags;
1606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1607                         if (r->location) {
1608                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1609                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1610                         }
1611                         ndr->flags = _flags_save_string;
1612                 }
1613                 if (r->devmode) {
1614                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1615                         {
1616                                 struct ndr_push *_ndr_devmode;
1617                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1618                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1619                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1620                         }
1621                 }
1622                 {
1623                         uint32_t _flags_save_string = ndr->flags;
1624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1625                         if (r->sepfile) {
1626                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1628                         }
1629                         ndr->flags = _flags_save_string;
1630                 }
1631                 {
1632                         uint32_t _flags_save_string = ndr->flags;
1633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1634                         if (r->printprocessor) {
1635                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1637                         }
1638                         ndr->flags = _flags_save_string;
1639                 }
1640                 {
1641                         uint32_t _flags_save_string = ndr->flags;
1642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1643                         if (r->datatype) {
1644                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1645                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
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                         if (r->parameters) {
1653                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1654                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1655                         }
1656                         ndr->flags = _flags_save_string;
1657                 }
1658                 if (r->secdesc) {
1659                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1660                         {
1661                                 struct ndr_push *_ndr_secdesc;
1662                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1663                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1664                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1665                         }
1666                 }
1667         }
1668         return NDR_ERR_SUCCESS;
1669 }
1670
1671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1672 {
1673         uint32_t _ptr_servername;
1674         TALLOC_CTX *_mem_save_servername_0;
1675         uint32_t _ptr_printername;
1676         TALLOC_CTX *_mem_save_printername_0;
1677         uint32_t _ptr_sharename;
1678         TALLOC_CTX *_mem_save_sharename_0;
1679         uint32_t _ptr_portname;
1680         TALLOC_CTX *_mem_save_portname_0;
1681         uint32_t _ptr_drivername;
1682         TALLOC_CTX *_mem_save_drivername_0;
1683         uint32_t _ptr_comment;
1684         TALLOC_CTX *_mem_save_comment_0;
1685         uint32_t _ptr_location;
1686         TALLOC_CTX *_mem_save_location_0;
1687         uint32_t _ptr_devmode;
1688         TALLOC_CTX *_mem_save_devmode_0;
1689         uint32_t _ptr_sepfile;
1690         TALLOC_CTX *_mem_save_sepfile_0;
1691         uint32_t _ptr_printprocessor;
1692         TALLOC_CTX *_mem_save_printprocessor_0;
1693         uint32_t _ptr_datatype;
1694         TALLOC_CTX *_mem_save_datatype_0;
1695         uint32_t _ptr_parameters;
1696         TALLOC_CTX *_mem_save_parameters_0;
1697         uint32_t _ptr_secdesc;
1698         TALLOC_CTX *_mem_save_secdesc_0;
1699         if (ndr_flags & NDR_SCALARS) {
1700                 NDR_CHECK(ndr_pull_align(ndr, 5));
1701                 {
1702                         uint32_t _flags_save_string = ndr->flags;
1703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1704                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1705                         if (_ptr_servername) {
1706                                 NDR_PULL_ALLOC(ndr, r->servername);
1707                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1708                         } else {
1709                                 r->servername = NULL;
1710                         }
1711                         ndr->flags = _flags_save_string;
1712                 }
1713                 {
1714                         uint32_t _flags_save_string = ndr->flags;
1715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1716                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1717                         if (_ptr_printername) {
1718                                 NDR_PULL_ALLOC(ndr, r->printername);
1719                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1720                         } else {
1721                                 r->printername = NULL;
1722                         }
1723                         ndr->flags = _flags_save_string;
1724                 }
1725                 {
1726                         uint32_t _flags_save_string = ndr->flags;
1727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1728                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1729                         if (_ptr_sharename) {
1730                                 NDR_PULL_ALLOC(ndr, r->sharename);
1731                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1732                         } else {
1733                                 r->sharename = NULL;
1734                         }
1735                         ndr->flags = _flags_save_string;
1736                 }
1737                 {
1738                         uint32_t _flags_save_string = ndr->flags;
1739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1740                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1741                         if (_ptr_portname) {
1742                                 NDR_PULL_ALLOC(ndr, r->portname);
1743                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1744                         } else {
1745                                 r->portname = NULL;
1746                         }
1747                         ndr->flags = _flags_save_string;
1748                 }
1749                 {
1750                         uint32_t _flags_save_string = ndr->flags;
1751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1752                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1753                         if (_ptr_drivername) {
1754                                 NDR_PULL_ALLOC(ndr, r->drivername);
1755                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1756                         } else {
1757                                 r->drivername = NULL;
1758                         }
1759                         ndr->flags = _flags_save_string;
1760                 }
1761                 {
1762                         uint32_t _flags_save_string = ndr->flags;
1763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1764                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1765                         if (_ptr_comment) {
1766                                 NDR_PULL_ALLOC(ndr, r->comment);
1767                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1768                         } else {
1769                                 r->comment = NULL;
1770                         }
1771                         ndr->flags = _flags_save_string;
1772                 }
1773                 {
1774                         uint32_t _flags_save_string = ndr->flags;
1775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1777                         if (_ptr_location) {
1778                                 NDR_PULL_ALLOC(ndr, r->location);
1779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1780                         } else {
1781                                 r->location = NULL;
1782                         }
1783                         ndr->flags = _flags_save_string;
1784                 }
1785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1786                 if (_ptr_devmode) {
1787                         NDR_PULL_ALLOC(ndr, r->devmode);
1788                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1789                 } else {
1790                         r->devmode = NULL;
1791                 }
1792                 {
1793                         uint32_t _flags_save_string = ndr->flags;
1794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1795                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1796                         if (_ptr_sepfile) {
1797                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1798                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1799                         } else {
1800                                 r->sepfile = NULL;
1801                         }
1802                         ndr->flags = _flags_save_string;
1803                 }
1804                 {
1805                         uint32_t _flags_save_string = ndr->flags;
1806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1807                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1808                         if (_ptr_printprocessor) {
1809                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1810                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1811                         } else {
1812                                 r->printprocessor = NULL;
1813                         }
1814                         ndr->flags = _flags_save_string;
1815                 }
1816                 {
1817                         uint32_t _flags_save_string = ndr->flags;
1818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1819                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1820                         if (_ptr_datatype) {
1821                                 NDR_PULL_ALLOC(ndr, r->datatype);
1822                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1823                         } else {
1824                                 r->datatype = NULL;
1825                         }
1826                         ndr->flags = _flags_save_string;
1827                 }
1828                 {
1829                         uint32_t _flags_save_string = ndr->flags;
1830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1832                         if (_ptr_parameters) {
1833                                 NDR_PULL_ALLOC(ndr, r->parameters);
1834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1835                         } else {
1836                                 r->parameters = NULL;
1837                         }
1838                         ndr->flags = _flags_save_string;
1839                 }
1840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1841                 if (_ptr_secdesc) {
1842                         NDR_PULL_ALLOC(ndr, r->secdesc);
1843                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1844                 } else {
1845                         r->secdesc = NULL;
1846                 }
1847                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1849                 if (r->priority > 99) {
1850                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1851                 }
1852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1855                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1858                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1859         }
1860         if (ndr_flags & NDR_BUFFERS) {
1861                 {
1862                         uint32_t _flags_save_string = ndr->flags;
1863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1864                         if (r->servername) {
1865                                 uint32_t _relative_save_offset;
1866                                 _relative_save_offset = ndr->offset;
1867                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1868                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1869                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1870                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1871                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1872                                 ndr->offset = _relative_save_offset;
1873                         }
1874                         ndr->flags = _flags_save_string;
1875                 }
1876                 {
1877                         uint32_t _flags_save_string = ndr->flags;
1878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1879                         if (r->printername) {
1880                                 uint32_t _relative_save_offset;
1881                                 _relative_save_offset = ndr->offset;
1882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1883                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1884                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1887                                 ndr->offset = _relative_save_offset;
1888                         }
1889                         ndr->flags = _flags_save_string;
1890                 }
1891                 {
1892                         uint32_t _flags_save_string = ndr->flags;
1893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1894                         if (r->sharename) {
1895                                 uint32_t _relative_save_offset;
1896                                 _relative_save_offset = ndr->offset;
1897                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1898                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1899                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1900                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1901                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1902                                 ndr->offset = _relative_save_offset;
1903                         }
1904                         ndr->flags = _flags_save_string;
1905                 }
1906                 {
1907                         uint32_t _flags_save_string = ndr->flags;
1908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1909                         if (r->portname) {
1910                                 uint32_t _relative_save_offset;
1911                                 _relative_save_offset = ndr->offset;
1912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1913                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1914                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1915                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1917                                 ndr->offset = _relative_save_offset;
1918                         }
1919                         ndr->flags = _flags_save_string;
1920                 }
1921                 {
1922                         uint32_t _flags_save_string = ndr->flags;
1923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1924                         if (r->drivername) {
1925                                 uint32_t _relative_save_offset;
1926                                 _relative_save_offset = ndr->offset;
1927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1928                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1929                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1932                                 ndr->offset = _relative_save_offset;
1933                         }
1934                         ndr->flags = _flags_save_string;
1935                 }
1936                 {
1937                         uint32_t _flags_save_string = ndr->flags;
1938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1939                         if (r->comment) {
1940                                 uint32_t _relative_save_offset;
1941                                 _relative_save_offset = ndr->offset;
1942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1943                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1944                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1947                                 ndr->offset = _relative_save_offset;
1948                         }
1949                         ndr->flags = _flags_save_string;
1950                 }
1951                 {
1952                         uint32_t _flags_save_string = ndr->flags;
1953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1954                         if (r->location) {
1955                                 uint32_t _relative_save_offset;
1956                                 _relative_save_offset = ndr->offset;
1957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1958                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966                 if (r->devmode) {
1967                         uint32_t _relative_save_offset;
1968                         _relative_save_offset = ndr->offset;
1969                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1970                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1971                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1972                         {
1973                                 struct ndr_pull *_ndr_devmode;
1974                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1975                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1976                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1977                         }
1978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1979                         ndr->offset = _relative_save_offset;
1980                 }
1981                 {
1982                         uint32_t _flags_save_string = ndr->flags;
1983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1984                         if (r->sepfile) {
1985                                 uint32_t _relative_save_offset;
1986                                 _relative_save_offset = ndr->offset;
1987                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1988                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1989                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1990                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1991                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1992                                 ndr->offset = _relative_save_offset;
1993                         }
1994                         ndr->flags = _flags_save_string;
1995                 }
1996                 {
1997                         uint32_t _flags_save_string = ndr->flags;
1998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1999                         if (r->printprocessor) {
2000                                 uint32_t _relative_save_offset;
2001                                 _relative_save_offset = ndr->offset;
2002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2003                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2004                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2007                                 ndr->offset = _relative_save_offset;
2008                         }
2009                         ndr->flags = _flags_save_string;
2010                 }
2011                 {
2012                         uint32_t _flags_save_string = ndr->flags;
2013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2014                         if (r->datatype) {
2015                                 uint32_t _relative_save_offset;
2016                                 _relative_save_offset = ndr->offset;
2017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2018                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2019                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2020                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2022                                 ndr->offset = _relative_save_offset;
2023                         }
2024                         ndr->flags = _flags_save_string;
2025                 }
2026                 {
2027                         uint32_t _flags_save_string = ndr->flags;
2028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2029                         if (r->parameters) {
2030                                 uint32_t _relative_save_offset;
2031                                 _relative_save_offset = ndr->offset;
2032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2033                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2034                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2037                                 ndr->offset = _relative_save_offset;
2038                         }
2039                         ndr->flags = _flags_save_string;
2040                 }
2041                 if (r->secdesc) {
2042                         uint32_t _relative_save_offset;
2043                         _relative_save_offset = ndr->offset;
2044                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2045                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2046                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2047                         {
2048                                 struct ndr_pull *_ndr_secdesc;
2049                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2050                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2051                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2052                         }
2053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2054                         ndr->offset = _relative_save_offset;
2055                 }
2056         }
2057         return NDR_ERR_SUCCESS;
2058 }
2059
2060 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2061 {
2062         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2063         ndr->depth++;
2064         ndr_print_ptr(ndr, "servername", r->servername);
2065         ndr->depth++;
2066         if (r->servername) {
2067                 ndr_print_string(ndr, "servername", r->servername);
2068         }
2069         ndr->depth--;
2070         ndr_print_ptr(ndr, "printername", r->printername);
2071         ndr->depth++;
2072         if (r->printername) {
2073                 ndr_print_string(ndr, "printername", r->printername);
2074         }
2075         ndr->depth--;
2076         ndr_print_ptr(ndr, "sharename", r->sharename);
2077         ndr->depth++;
2078         if (r->sharename) {
2079                 ndr_print_string(ndr, "sharename", r->sharename);
2080         }
2081         ndr->depth--;
2082         ndr_print_ptr(ndr, "portname", r->portname);
2083         ndr->depth++;
2084         if (r->portname) {
2085                 ndr_print_string(ndr, "portname", r->portname);
2086         }
2087         ndr->depth--;
2088         ndr_print_ptr(ndr, "drivername", r->drivername);
2089         ndr->depth++;
2090         if (r->drivername) {
2091                 ndr_print_string(ndr, "drivername", r->drivername);
2092         }
2093         ndr->depth--;
2094         ndr_print_ptr(ndr, "comment", r->comment);
2095         ndr->depth++;
2096         if (r->comment) {
2097                 ndr_print_string(ndr, "comment", r->comment);
2098         }
2099         ndr->depth--;
2100         ndr_print_ptr(ndr, "location", r->location);
2101         ndr->depth++;
2102         if (r->location) {
2103                 ndr_print_string(ndr, "location", r->location);
2104         }
2105         ndr->depth--;
2106         ndr_print_ptr(ndr, "devmode", r->devmode);
2107         ndr->depth++;
2108         if (r->devmode) {
2109                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2110         }
2111         ndr->depth--;
2112         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2113         ndr->depth++;
2114         if (r->sepfile) {
2115                 ndr_print_string(ndr, "sepfile", r->sepfile);
2116         }
2117         ndr->depth--;
2118         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2119         ndr->depth++;
2120         if (r->printprocessor) {
2121                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2122         }
2123         ndr->depth--;
2124         ndr_print_ptr(ndr, "datatype", r->datatype);
2125         ndr->depth++;
2126         if (r->datatype) {
2127                 ndr_print_string(ndr, "datatype", r->datatype);
2128         }
2129         ndr->depth--;
2130         ndr_print_ptr(ndr, "parameters", r->parameters);
2131         ndr->depth++;
2132         if (r->parameters) {
2133                 ndr_print_string(ndr, "parameters", r->parameters);
2134         }
2135         ndr->depth--;
2136         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2137         ndr->depth++;
2138         if (r->secdesc) {
2139                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2140         }
2141         ndr->depth--;
2142         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2143         ndr_print_uint32(ndr, "priority", r->priority);
2144         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2145         ndr_print_uint32(ndr, "starttime", r->starttime);
2146         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2147         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2148         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2149         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2150         ndr->depth--;
2151 }
2152
2153 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2154 {
2155         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2156 }
2157
2158 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2159 {
2160         if (ndr_flags & NDR_SCALARS) {
2161                 NDR_CHECK(ndr_push_align(ndr, 5));
2162                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2163                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2164         }
2165         if (ndr_flags & NDR_BUFFERS) {
2166                 if (r->secdesc) {
2167                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
2168                         {
2169                                 struct ndr_push *_ndr_secdesc;
2170                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2171                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2172                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2173                         }
2174                 }
2175         }
2176         return NDR_ERR_SUCCESS;
2177 }
2178
2179 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2180 {
2181         uint32_t _ptr_secdesc;
2182         TALLOC_CTX *_mem_save_secdesc_0;
2183         if (ndr_flags & NDR_SCALARS) {
2184                 NDR_CHECK(ndr_pull_align(ndr, 5));
2185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2186                 if (_ptr_secdesc) {
2187                         NDR_PULL_ALLOC(ndr, r->secdesc);
2188                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2189                 } else {
2190                         r->secdesc = NULL;
2191                 }
2192                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2193         }
2194         if (ndr_flags & NDR_BUFFERS) {
2195                 if (r->secdesc) {
2196                         uint32_t _relative_save_offset;
2197                         _relative_save_offset = ndr->offset;
2198                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2199                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2200                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2201                         {
2202                                 struct ndr_pull *_ndr_secdesc;
2203                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2204                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2205                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2206                         }
2207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2208                         ndr->offset = _relative_save_offset;
2209                 }
2210         }
2211         return NDR_ERR_SUCCESS;
2212 }
2213
2214 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2215 {
2216         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2217         ndr->depth++;
2218         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2219         ndr->depth++;
2220         if (r->secdesc) {
2221                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2222         }
2223         ndr->depth--;
2224         ndr->depth--;
2225 }
2226
2227 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2228 {
2229         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2230 }
2231
2232 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2233 {
2234         if (ndr_flags & NDR_SCALARS) {
2235                 NDR_CHECK(ndr_push_align(ndr, 5));
2236                 {
2237                         uint32_t _flags_save_string = ndr->flags;
2238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2239                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2240                         ndr->flags = _flags_save_string;
2241                 }
2242                 {
2243                         uint32_t _flags_save_string = ndr->flags;
2244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2245                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2246                         ndr->flags = _flags_save_string;
2247                 }
2248                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2249                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2250         }
2251         if (ndr_flags & NDR_BUFFERS) {
2252                 {
2253                         uint32_t _flags_save_string = ndr->flags;
2254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2255                         if (r->printername) {
2256                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2257                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2258                         }
2259                         ndr->flags = _flags_save_string;
2260                 }
2261                 {
2262                         uint32_t _flags_save_string = ndr->flags;
2263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2264                         if (r->servername) {
2265                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
2266                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2267                         }
2268                         ndr->flags = _flags_save_string;
2269                 }
2270         }
2271         return NDR_ERR_SUCCESS;
2272 }
2273
2274 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2275 {
2276         uint32_t _ptr_printername;
2277         TALLOC_CTX *_mem_save_printername_0;
2278         uint32_t _ptr_servername;
2279         TALLOC_CTX *_mem_save_servername_0;
2280         if (ndr_flags & NDR_SCALARS) {
2281                 NDR_CHECK(ndr_pull_align(ndr, 5));
2282                 {
2283                         uint32_t _flags_save_string = ndr->flags;
2284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2285                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2286                         if (_ptr_printername) {
2287                                 NDR_PULL_ALLOC(ndr, r->printername);
2288                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2289                         } else {
2290                                 r->printername = NULL;
2291                         }
2292                         ndr->flags = _flags_save_string;
2293                 }
2294                 {
2295                         uint32_t _flags_save_string = ndr->flags;
2296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2297                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2298                         if (_ptr_servername) {
2299                                 NDR_PULL_ALLOC(ndr, r->servername);
2300                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2301                         } else {
2302                                 r->servername = NULL;
2303                         }
2304                         ndr->flags = _flags_save_string;
2305                 }
2306                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2307                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2308         }
2309         if (ndr_flags & NDR_BUFFERS) {
2310                 {
2311                         uint32_t _flags_save_string = ndr->flags;
2312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2313                         if (r->printername) {
2314                                 uint32_t _relative_save_offset;
2315                                 _relative_save_offset = ndr->offset;
2316                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2317                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2318                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2319                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2320                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2321                                 ndr->offset = _relative_save_offset;
2322                         }
2323                         ndr->flags = _flags_save_string;
2324                 }
2325                 {
2326                         uint32_t _flags_save_string = ndr->flags;
2327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2328                         if (r->servername) {
2329                                 uint32_t _relative_save_offset;
2330                                 _relative_save_offset = ndr->offset;
2331                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2332                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2333                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2334                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2335                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2336                                 ndr->offset = _relative_save_offset;
2337                         }
2338                         ndr->flags = _flags_save_string;
2339                 }
2340         }
2341         return NDR_ERR_SUCCESS;
2342 }
2343
2344 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2345 {
2346         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2347         ndr->depth++;
2348         ndr_print_ptr(ndr, "printername", r->printername);
2349         ndr->depth++;
2350         if (r->printername) {
2351                 ndr_print_string(ndr, "printername", r->printername);
2352         }
2353         ndr->depth--;
2354         ndr_print_ptr(ndr, "servername", r->servername);
2355         ndr->depth++;
2356         if (r->servername) {
2357                 ndr_print_string(ndr, "servername", r->servername);
2358         }
2359         ndr->depth--;
2360         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2361         ndr->depth--;
2362 }
2363
2364 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2365 {
2366         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2367 }
2368
2369 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2370 {
2371         if (ndr_flags & NDR_SCALARS) {
2372                 NDR_CHECK(ndr_push_align(ndr, 5));
2373                 {
2374                         uint32_t _flags_save_string = ndr->flags;
2375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2376                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2377                         ndr->flags = _flags_save_string;
2378                 }
2379                 {
2380                         uint32_t _flags_save_string = ndr->flags;
2381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2382                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2383                         ndr->flags = _flags_save_string;
2384                 }
2385                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2388                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2389         }
2390         if (ndr_flags & NDR_BUFFERS) {
2391                 {
2392                         uint32_t _flags_save_string = ndr->flags;
2393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2394                         if (r->printername) {
2395                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2396                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2397                         }
2398                         ndr->flags = _flags_save_string;
2399                 }
2400                 {
2401                         uint32_t _flags_save_string = ndr->flags;
2402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2403                         if (r->portname) {
2404                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
2405                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2406                         }
2407                         ndr->flags = _flags_save_string;
2408                 }
2409         }
2410         return NDR_ERR_SUCCESS;
2411 }
2412
2413 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2414 {
2415         uint32_t _ptr_printername;
2416         TALLOC_CTX *_mem_save_printername_0;
2417         uint32_t _ptr_portname;
2418         TALLOC_CTX *_mem_save_portname_0;
2419         if (ndr_flags & NDR_SCALARS) {
2420                 NDR_CHECK(ndr_pull_align(ndr, 5));
2421                 {
2422                         uint32_t _flags_save_string = ndr->flags;
2423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2424                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2425                         if (_ptr_printername) {
2426                                 NDR_PULL_ALLOC(ndr, r->printername);
2427                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2428                         } else {
2429                                 r->printername = NULL;
2430                         }
2431                         ndr->flags = _flags_save_string;
2432                 }
2433                 {
2434                         uint32_t _flags_save_string = ndr->flags;
2435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2436                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2437                         if (_ptr_portname) {
2438                                 NDR_PULL_ALLOC(ndr, r->portname);
2439                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2440                         } else {
2441                                 r->portname = NULL;
2442                         }
2443                         ndr->flags = _flags_save_string;
2444                 }
2445                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2448                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2449         }
2450         if (ndr_flags & NDR_BUFFERS) {
2451                 {
2452                         uint32_t _flags_save_string = ndr->flags;
2453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2454                         if (r->printername) {
2455                                 uint32_t _relative_save_offset;
2456                                 _relative_save_offset = ndr->offset;
2457                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2458                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2459                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2460                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2461                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2462                                 ndr->offset = _relative_save_offset;
2463                         }
2464                         ndr->flags = _flags_save_string;
2465                 }
2466                 {
2467                         uint32_t _flags_save_string = ndr->flags;
2468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2469                         if (r->portname) {
2470                                 uint32_t _relative_save_offset;
2471                                 _relative_save_offset = ndr->offset;
2472                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2473                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2474                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2475                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2476                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2477                                 ndr->offset = _relative_save_offset;
2478                         }
2479                         ndr->flags = _flags_save_string;
2480                 }
2481         }
2482         return NDR_ERR_SUCCESS;
2483 }
2484
2485 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2486 {
2487         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2488         ndr->depth++;
2489         ndr_print_ptr(ndr, "printername", r->printername);
2490         ndr->depth++;
2491         if (r->printername) {
2492                 ndr_print_string(ndr, "printername", r->printername);
2493         }
2494         ndr->depth--;
2495         ndr_print_ptr(ndr, "portname", r->portname);
2496         ndr->depth++;
2497         if (r->portname) {
2498                 ndr_print_string(ndr, "portname", r->portname);
2499         }
2500         ndr->depth--;
2501         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2502         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2503         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2504         ndr->depth--;
2505 }
2506
2507 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2508 {
2509         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2510 }
2511
2512 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2513 {
2514         if (ndr_flags & NDR_SCALARS) {
2515                 NDR_CHECK(ndr_push_align(ndr, 4));
2516                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2517                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2518         }
2519         if (ndr_flags & NDR_BUFFERS) {
2520         }
2521         return NDR_ERR_SUCCESS;
2522 }
2523
2524 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2525 {
2526         if (ndr_flags & NDR_SCALARS) {
2527                 NDR_CHECK(ndr_pull_align(ndr, 4));
2528                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2529                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2530         }
2531         if (ndr_flags & NDR_BUFFERS) {
2532         }
2533         return NDR_ERR_SUCCESS;
2534 }
2535
2536 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2537 {
2538         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2539         ndr->depth++;
2540         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2541         ndr->depth--;
2542 }
2543
2544 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2545 {
2546         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2547 }
2548
2549 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2550 {
2551         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2552         return NDR_ERR_SUCCESS;
2553 }
2554
2555 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2556 {
2557         uint32_t v;
2558         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2559         *r = v;
2560         return NDR_ERR_SUCCESS;
2561 }
2562
2563 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2564 {
2565         ndr_print_uint32(ndr, name, r);
2566         ndr->depth++;
2567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2572         ndr->depth--;
2573 }
2574
2575 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2576 {
2577         if (ndr_flags & NDR_SCALARS) {
2578                 NDR_CHECK(ndr_push_align(ndr, 5));
2579                 {
2580                         uint32_t _flags_save_string = ndr->flags;
2581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2582                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2583                         ndr->flags = _flags_save_string;
2584                 }
2585                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2586                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2587         }
2588         if (ndr_flags & NDR_BUFFERS) {
2589                 {
2590                         uint32_t _flags_save_string = ndr->flags;
2591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2592                         if (r->guid) {
2593                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2594                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2595                         }
2596                         ndr->flags = _flags_save_string;
2597                 }
2598         }
2599         return NDR_ERR_SUCCESS;
2600 }
2601
2602 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2603 {
2604         uint32_t _ptr_guid;
2605         TALLOC_CTX *_mem_save_guid_0;
2606         if (ndr_flags & NDR_SCALARS) {
2607                 NDR_CHECK(ndr_pull_align(ndr, 5));
2608                 {
2609                         uint32_t _flags_save_string = ndr->flags;
2610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2611                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2612                         if (_ptr_guid) {
2613                                 NDR_PULL_ALLOC(ndr, r->guid);
2614                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2615                         } else {
2616                                 r->guid = NULL;
2617                         }
2618                         ndr->flags = _flags_save_string;
2619                 }
2620                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2621                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2622         }
2623         if (ndr_flags & NDR_BUFFERS) {
2624                 {
2625                         uint32_t _flags_save_string = ndr->flags;
2626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2627                         if (r->guid) {
2628                                 uint32_t _relative_save_offset;
2629                                 _relative_save_offset = ndr->offset;
2630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2631                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2632                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2635                                 ndr->offset = _relative_save_offset;
2636                         }
2637                         ndr->flags = _flags_save_string;
2638                 }
2639         }
2640         return NDR_ERR_SUCCESS;
2641 }
2642
2643 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2644 {
2645         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2646         ndr->depth++;
2647         ndr_print_ptr(ndr, "guid", r->guid);
2648         ndr->depth++;
2649         if (r->guid) {
2650                 ndr_print_string(ndr, "guid", r->guid);
2651         }
2652         ndr->depth--;
2653         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2654         ndr->depth--;
2655 }
2656
2657 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2658 {
2659         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2660 }
2661
2662 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2663 {
2664         if (ndr_flags & NDR_SCALARS) {
2665                 NDR_CHECK(ndr_push_align(ndr, 5));
2666                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2667                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2668         }
2669         if (ndr_flags & NDR_BUFFERS) {
2670                 if (r->devmode) {
2671                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2672                         {
2673                                 struct ndr_push *_ndr_devmode;
2674                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2675                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2676                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2677                         }
2678                 }
2679         }
2680         return NDR_ERR_SUCCESS;
2681 }
2682
2683 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2684 {
2685         uint32_t _ptr_devmode;
2686         TALLOC_CTX *_mem_save_devmode_0;
2687         if (ndr_flags & NDR_SCALARS) {
2688                 NDR_CHECK(ndr_pull_align(ndr, 5));
2689                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2690                 if (_ptr_devmode) {
2691                         NDR_PULL_ALLOC(ndr, r->devmode);
2692                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2693                 } else {
2694                         r->devmode = NULL;
2695                 }
2696                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2697         }
2698         if (ndr_flags & NDR_BUFFERS) {
2699                 if (r->devmode) {
2700                         uint32_t _relative_save_offset;
2701                         _relative_save_offset = ndr->offset;
2702                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2703                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2704                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2705                         {
2706                                 struct ndr_pull *_ndr_devmode;
2707                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2708                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2709                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2710                         }
2711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2712                         ndr->offset = _relative_save_offset;
2713                 }
2714         }
2715         return NDR_ERR_SUCCESS;
2716 }
2717
2718 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2719 {
2720         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2721         ndr->depth++;
2722         ndr_print_ptr(ndr, "devmode", r->devmode);
2723         ndr->depth++;
2724         if (r->devmode) {
2725                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2726         }
2727         ndr->depth--;
2728         ndr->depth--;
2729 }
2730
2731 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2732 {
2733         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2734         if (ndr_flags & NDR_SCALARS) {
2735                 int level = ndr_push_get_switch_value(ndr, r);
2736                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2737                 switch (level) {
2738                         case 0: {
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_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2742                         break; }
2743
2744                         case 1: {
2745                                 NDR_CHECK(ndr_push_align(ndr, 5));
2746                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2747                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2748                         break; }
2749
2750                         case 2: {
2751                                 NDR_CHECK(ndr_push_align(ndr, 5));
2752                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2753                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2754                         break; }
2755
2756                         case 3: {
2757                                 NDR_CHECK(ndr_push_align(ndr, 5));
2758                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2759                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2760                         break; }
2761
2762                         case 4: {
2763                                 NDR_CHECK(ndr_push_align(ndr, 5));
2764                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2765                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2766                         break; }
2767
2768                         case 5: {
2769                                 NDR_CHECK(ndr_push_align(ndr, 5));
2770                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2771                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2772                         break; }
2773
2774                         case 6: {
2775                                 NDR_CHECK(ndr_push_align(ndr, 4));
2776                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2777                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2778                         break; }
2779
2780                         case 7: {
2781                                 NDR_CHECK(ndr_push_align(ndr, 5));
2782                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2783                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2784                         break; }
2785
2786                         case 8: {
2787                                 NDR_CHECK(ndr_push_align(ndr, 5));
2788                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2789                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2790                         break; }
2791
2792                         case 9: {
2793                                 NDR_CHECK(ndr_push_align(ndr, 5));
2794                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2795                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2796                         break; }
2797
2798                         default: {
2799                         break; }
2800
2801                 }
2802         }
2803         if (ndr_flags & NDR_BUFFERS) {
2804                 int level = ndr_push_get_switch_value(ndr, r);
2805                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2806                 switch (level) {
2807                         case 0:
2808                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2809                         break;
2810
2811                         case 1:
2812                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2813                         break;
2814
2815                         case 2:
2816                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2817                         break;
2818
2819                         case 3:
2820                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2821                         break;
2822
2823                         case 4:
2824                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2825                         break;
2826
2827                         case 5:
2828                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2829                         break;
2830
2831                         case 6:
2832                         break;
2833
2834                         case 7:
2835                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2836                         break;
2837
2838                         case 8:
2839                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2840                         break;
2841
2842                         case 9:
2843                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2844                         break;
2845
2846                         default:
2847                         break;
2848
2849                 }
2850         }
2851         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2852         return NDR_ERR_SUCCESS;
2853 }
2854
2855 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2856 {
2857         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2858         int level;
2859         level = ndr_pull_get_switch_value(ndr, r);
2860         if (ndr_flags & NDR_SCALARS) {
2861                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2862                 switch (level) {
2863                         case 0: {
2864                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2865                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2866                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2867                         break; }
2868
2869                         case 1: {
2870                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2871                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2872                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2873                         break; }
2874
2875                         case 2: {
2876                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2877                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2878                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2879                         break; }
2880
2881                         case 3: {
2882                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2883                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2884                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2885                         break; }
2886
2887                         case 4: {
2888                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2889                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2890                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2891                         break; }
2892
2893                         case 5: {
2894                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2895                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2896                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2897                         break; }
2898
2899                         case 6: {
2900                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2901                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2902                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2903                         break; }
2904
2905                         case 7: {
2906                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2907                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2908                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2909                         break; }
2910
2911                         case 8: {
2912                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2913                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2914                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2915                         break; }
2916
2917                         case 9: {
2918                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2919                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2920                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2921                         break; }
2922
2923                         default: {
2924                         break; }
2925
2926                 }
2927         }
2928         if (ndr_flags & NDR_BUFFERS) {
2929                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2930                 switch (level) {
2931                         case 0:
2932                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2933                         break;
2934
2935                         case 1:
2936                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2937                         break;
2938
2939                         case 2:
2940                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2941                         break;
2942
2943                         case 3:
2944                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2945                         break;
2946
2947                         case 4:
2948                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2949                         break;
2950
2951                         case 5:
2952                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2953                         break;
2954
2955                         case 6:
2956                         break;
2957
2958                         case 7:
2959                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2960                         break;
2961
2962                         case 8:
2963                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2964                         break;
2965
2966                         case 9:
2967                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2968                         break;
2969
2970                         default:
2971                         break;
2972
2973                 }
2974         }
2975         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2976         return NDR_ERR_SUCCESS;
2977 }
2978
2979 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2980 {
2981         int level;
2982         level = ndr_print_get_switch_value(ndr, r);
2983         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2984         switch (level) {
2985                 case 0:
2986                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2987                 break;
2988
2989                 case 1:
2990                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2991                 break;
2992
2993                 case 2:
2994                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2995                 break;
2996
2997                 case 3:
2998                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2999                 break;
3000
3001                 case 4:
3002                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3003                 break;
3004
3005                 case 5:
3006                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3007                 break;
3008
3009                 case 6:
3010                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3011                 break;
3012
3013                 case 7:
3014                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3015                 break;
3016
3017                 case 8:
3018                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3019                 break;
3020
3021                 case 9:
3022                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3023                 break;
3024
3025                 default:
3026                 break;
3027
3028         }
3029 }
3030
3031 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3032 {
3033         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3034 }
3035
3036 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3037 {
3038         if (ndr_flags & NDR_SCALARS) {
3039                 NDR_CHECK(ndr_push_align(ndr, 5));
3040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3042                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3043         }
3044         if (ndr_flags & NDR_BUFFERS) {
3045                 if (r->devmode) {
3046                         {
3047                                 struct ndr_push *_ndr_devmode;
3048                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3049                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3050                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3051                         }
3052                 }
3053         }
3054         return NDR_ERR_SUCCESS;
3055 }
3056
3057 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3058 {
3059         uint32_t _ptr_devmode;
3060         TALLOC_CTX *_mem_save_devmode_0;
3061         if (ndr_flags & NDR_SCALARS) {
3062                 NDR_CHECK(ndr_pull_align(ndr, 5));
3063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3065                 if (_ptr_devmode) {
3066                         NDR_PULL_ALLOC(ndr, r->devmode);
3067                 } else {
3068                         r->devmode = NULL;
3069                 }
3070                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3071         }
3072         if (ndr_flags & NDR_BUFFERS) {
3073                 if (r->devmode) {
3074                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3075                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3076                         {
3077                                 struct ndr_pull *_ndr_devmode;
3078                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3079                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3080                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3081                         }
3082                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3083                 }
3084         }
3085         return NDR_ERR_SUCCESS;
3086 }
3087
3088 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3089 {
3090         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3091         ndr->depth++;
3092         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);
3093         ndr_print_ptr(ndr, "devmode", r->devmode);
3094         ndr->depth++;
3095         if (r->devmode) {
3096                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3097         }
3098         ndr->depth--;
3099         ndr->depth--;
3100 }
3101
3102 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3103 {
3104         if (ndr_flags & NDR_SCALARS) {
3105                 NDR_CHECK(ndr_push_align(ndr, 5));
3106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3107                 {
3108                         uint32_t _flags_save_string = ndr->flags;
3109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3110                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3111                         ndr->flags = _flags_save_string;
3112                 }
3113                 {
3114                         uint32_t _flags_save_string = ndr->flags;
3115                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3116                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3117                         ndr->flags = _flags_save_string;
3118                 }
3119                 {
3120                         uint32_t _flags_save_string = ndr->flags;
3121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3122                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3123                         ndr->flags = _flags_save_string;
3124                 }
3125                 {
3126                         uint32_t _flags_save_string = ndr->flags;
3127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3128                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3135                         ndr->flags = _flags_save_string;
3136                 }
3137                 {
3138                         uint32_t _flags_save_string = ndr->flags;
3139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3140                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3141                         ndr->flags = _flags_save_string;
3142                 }
3143                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3148                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3149                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3150         }
3151         if (ndr_flags & NDR_BUFFERS) {
3152                 {
3153                         uint32_t _flags_save_string = ndr->flags;
3154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3155                         if (r->printer_name) {
3156                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3157                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
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->server_name) {
3165                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3166                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3167                         }
3168                         ndr->flags = _flags_save_string;
3169                 }
3170                 {
3171                         uint32_t _flags_save_string = ndr->flags;
3172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3173                         if (r->user_name) {
3174                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3175                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3176                         }
3177                         ndr->flags = _flags_save_string;
3178                 }
3179                 {
3180                         uint32_t _flags_save_string = ndr->flags;
3181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3182                         if (r->document_name) {
3183                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3184                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3185                         }
3186                         ndr->flags = _flags_save_string;
3187                 }
3188                 {
3189                         uint32_t _flags_save_string = ndr->flags;
3190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3191                         if (r->data_type) {
3192                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3193                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3194                         }
3195                         ndr->flags = _flags_save_string;
3196                 }
3197                 {
3198                         uint32_t _flags_save_string = ndr->flags;
3199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3200                         if (r->text_status) {
3201                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3202                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3203                         }
3204                         ndr->flags = _flags_save_string;
3205                 }
3206         }
3207         return NDR_ERR_SUCCESS;
3208 }
3209
3210 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3211 {
3212         uint32_t _ptr_printer_name;
3213         TALLOC_CTX *_mem_save_printer_name_0;
3214         uint32_t _ptr_server_name;
3215         TALLOC_CTX *_mem_save_server_name_0;
3216         uint32_t _ptr_user_name;
3217         TALLOC_CTX *_mem_save_user_name_0;
3218         uint32_t _ptr_document_name;
3219         TALLOC_CTX *_mem_save_document_name_0;
3220         uint32_t _ptr_data_type;
3221         TALLOC_CTX *_mem_save_data_type_0;
3222         uint32_t _ptr_text_status;
3223         TALLOC_CTX *_mem_save_text_status_0;
3224         if (ndr_flags & NDR_SCALARS) {
3225                 NDR_CHECK(ndr_pull_align(ndr, 5));
3226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3227                 {
3228                         uint32_t _flags_save_string = ndr->flags;
3229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3230                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3231                         if (_ptr_printer_name) {
3232                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3233                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3234                         } else {
3235                                 r->printer_name = NULL;
3236                         }
3237                         ndr->flags = _flags_save_string;
3238                 }
3239                 {
3240                         uint32_t _flags_save_string = ndr->flags;
3241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3242                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3243                         if (_ptr_server_name) {
3244                                 NDR_PULL_ALLOC(ndr, r->server_name);
3245                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3246                         } else {
3247                                 r->server_name = NULL;
3248                         }
3249                         ndr->flags = _flags_save_string;
3250                 }
3251                 {
3252                         uint32_t _flags_save_string = ndr->flags;
3253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3254                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3255                         if (_ptr_user_name) {
3256                                 NDR_PULL_ALLOC(ndr, r->user_name);
3257                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3258                         } else {
3259                                 r->user_name = NULL;
3260                         }
3261                         ndr->flags = _flags_save_string;
3262                 }
3263                 {
3264                         uint32_t _flags_save_string = ndr->flags;
3265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3266                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3267                         if (_ptr_document_name) {
3268                                 NDR_PULL_ALLOC(ndr, r->document_name);
3269                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3270                         } else {
3271                                 r->document_name = NULL;
3272                         }
3273                         ndr->flags = _flags_save_string;
3274                 }
3275                 {
3276                         uint32_t _flags_save_string = ndr->flags;
3277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3278                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3279                         if (_ptr_data_type) {
3280                                 NDR_PULL_ALLOC(ndr, r->data_type);
3281                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3282                         } else {
3283                                 r->data_type = NULL;
3284                         }
3285                         ndr->flags = _flags_save_string;
3286                 }
3287                 {
3288                         uint32_t _flags_save_string = ndr->flags;
3289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3290                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3291                         if (_ptr_text_status) {
3292                                 NDR_PULL_ALLOC(ndr, r->text_status);
3293                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3294                         } else {
3295                                 r->text_status = NULL;
3296                         }
3297                         ndr->flags = _flags_save_string;
3298                 }
3299                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3301                 if (r->priority > 99) {
3302                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3303                 }
3304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3307                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3308                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3309         }
3310         if (ndr_flags & NDR_BUFFERS) {
3311                 {
3312                         uint32_t _flags_save_string = ndr->flags;
3313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3314                         if (r->printer_name) {
3315                                 uint32_t _relative_save_offset;
3316                                 _relative_save_offset = ndr->offset;
3317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3318                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3319                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3322                                 ndr->offset = _relative_save_offset;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         if (r->server_name) {
3330                                 uint32_t _relative_save_offset;
3331                                 _relative_save_offset = ndr->offset;
3332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3333                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3334                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3337                                 ndr->offset = _relative_save_offset;
3338                         }
3339                         ndr->flags = _flags_save_string;
3340                 }
3341                 {
3342                         uint32_t _flags_save_string = ndr->flags;
3343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3344                         if (r->user_name) {
3345                                 uint32_t _relative_save_offset;
3346                                 _relative_save_offset = ndr->offset;
3347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3348                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3349                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3352                                 ndr->offset = _relative_save_offset;
3353                         }
3354                         ndr->flags = _flags_save_string;
3355                 }
3356                 {
3357                         uint32_t _flags_save_string = ndr->flags;
3358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3359                         if (r->document_name) {
3360                                 uint32_t _relative_save_offset;
3361                                 _relative_save_offset = ndr->offset;
3362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3363                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3364                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3367                                 ndr->offset = _relative_save_offset;
3368                         }
3369                         ndr->flags = _flags_save_string;
3370                 }
3371                 {
3372                         uint32_t _flags_save_string = ndr->flags;
3373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3374                         if (r->data_type) {
3375                                 uint32_t _relative_save_offset;
3376                                 _relative_save_offset = ndr->offset;
3377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3378                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3379                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3382                                 ndr->offset = _relative_save_offset;
3383                         }
3384                         ndr->flags = _flags_save_string;
3385                 }
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->text_status) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3393                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3397                                 ndr->offset = _relative_save_offset;
3398                         }
3399                         ndr->flags = _flags_save_string;
3400                 }
3401         }
3402         return NDR_ERR_SUCCESS;
3403 }
3404
3405 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3406 {
3407         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3408         ndr->depth++;
3409         ndr_print_uint32(ndr, "job_id", r->job_id);
3410         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3411         ndr->depth++;
3412         if (r->printer_name) {
3413                 ndr_print_string(ndr, "printer_name", r->printer_name);
3414         }
3415         ndr->depth--;
3416         ndr_print_ptr(ndr, "server_name", r->server_name);
3417         ndr->depth++;
3418         if (r->server_name) {
3419                 ndr_print_string(ndr, "server_name", r->server_name);
3420         }
3421         ndr->depth--;
3422         ndr_print_ptr(ndr, "user_name", r->user_name);
3423         ndr->depth++;
3424         if (r->user_name) {
3425                 ndr_print_string(ndr, "user_name", r->user_name);
3426         }
3427         ndr->depth--;
3428         ndr_print_ptr(ndr, "document_name", r->document_name);
3429         ndr->depth++;
3430         if (r->document_name) {
3431                 ndr_print_string(ndr, "document_name", r->document_name);
3432         }
3433         ndr->depth--;
3434         ndr_print_ptr(ndr, "data_type", r->data_type);
3435         ndr->depth++;
3436         if (r->data_type) {
3437                 ndr_print_string(ndr, "data_type", r->data_type);
3438         }
3439         ndr->depth--;
3440         ndr_print_ptr(ndr, "text_status", r->text_status);
3441         ndr->depth++;
3442         if (r->text_status) {
3443                 ndr_print_string(ndr, "text_status", r->text_status);
3444         }
3445         ndr->depth--;
3446         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3447         ndr_print_uint32(ndr, "priority", r->priority);
3448         ndr_print_uint32(ndr, "position", r->position);
3449         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3450         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3451         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3452         ndr->depth--;
3453 }
3454
3455 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3456 {
3457         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3458 }
3459
3460 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3461 {
3462         if (ndr_flags & NDR_SCALARS) {
3463                 NDR_CHECK(ndr_push_align(ndr, 5));
3464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3465                 {
3466                         uint32_t _flags_save_string = ndr->flags;
3467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3468                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3469                         ndr->flags = _flags_save_string;
3470                 }
3471                 {
3472                         uint32_t _flags_save_string = ndr->flags;
3473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3474                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3475                         ndr->flags = _flags_save_string;
3476                 }
3477                 {
3478                         uint32_t _flags_save_string = ndr->flags;
3479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3481                         ndr->flags = _flags_save_string;
3482                 }
3483                 {
3484                         uint32_t _flags_save_string = ndr->flags;
3485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3487                         ndr->flags = _flags_save_string;
3488                 }
3489                 {
3490                         uint32_t _flags_save_string = ndr->flags;
3491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3493                         ndr->flags = _flags_save_string;
3494                 }
3495                 {
3496                         uint32_t _flags_save_string = ndr->flags;
3497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3499                         ndr->flags = _flags_save_string;
3500                 }
3501                 {
3502                         uint32_t _flags_save_string = ndr->flags;
3503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3505                         ndr->flags = _flags_save_string;
3506                 }
3507                 {
3508                         uint32_t _flags_save_string = ndr->flags;
3509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3511                         ndr->flags = _flags_save_string;
3512                 }
3513                 {
3514                         uint32_t _flags_save_string = ndr->flags;
3515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3516                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3517                         ndr->flags = _flags_save_string;
3518                 }
3519                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3520                 {
3521                         uint32_t _flags_save_string = ndr->flags;
3522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3524                         ndr->flags = _flags_save_string;
3525                 }
3526                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3527                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3534                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3537                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3538         }
3539         if (ndr_flags & NDR_BUFFERS) {
3540                 {
3541                         uint32_t _flags_save_string = ndr->flags;
3542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3543                         if (r->printer_name) {
3544                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3545                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3546                         }
3547                         ndr->flags = _flags_save_string;
3548                 }
3549                 {
3550                         uint32_t _flags_save_string = ndr->flags;
3551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3552                         if (r->server_name) {
3553                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3554                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3555                         }
3556                         ndr->flags = _flags_save_string;
3557                 }
3558                 {
3559                         uint32_t _flags_save_string = ndr->flags;
3560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3561                         if (r->user_name) {
3562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3564                         }
3565                         ndr->flags = _flags_save_string;
3566                 }
3567                 {
3568                         uint32_t _flags_save_string = ndr->flags;
3569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3570                         if (r->document_name) {
3571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3573                         }
3574                         ndr->flags = _flags_save_string;
3575                 }
3576                 {
3577                         uint32_t _flags_save_string = ndr->flags;
3578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3579                         if (r->notify_name) {
3580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3582                         }
3583                         ndr->flags = _flags_save_string;
3584                 }
3585                 {
3586                         uint32_t _flags_save_string = ndr->flags;
3587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3588                         if (r->data_type) {
3589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3591                         }
3592                         ndr->flags = _flags_save_string;
3593                 }
3594                 {
3595                         uint32_t _flags_save_string = ndr->flags;
3596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3597                         if (r->print_processor) {
3598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, 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(ndr, r->parameters));
3608                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3609                         }
3610                         ndr->flags = _flags_save_string;
3611                 }
3612                 {
3613                         uint32_t _flags_save_string = ndr->flags;
3614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3615                         if (r->driver_name) {
3616                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3617                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3618                         }
3619                         ndr->flags = _flags_save_string;
3620                 }
3621                 if (r->devmode) {
3622                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3623                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3624                 }
3625                 {
3626                         uint32_t _flags_save_string = ndr->flags;
3627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3628                         if (r->text_status) {
3629                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3630                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3631                         }
3632                         ndr->flags = _flags_save_string;
3633                 }
3634                 if (r->secdesc) {
3635                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3636                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3637                 }
3638         }
3639         return NDR_ERR_SUCCESS;
3640 }
3641
3642 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3643 {
3644         uint32_t _ptr_printer_name;
3645         TALLOC_CTX *_mem_save_printer_name_0;
3646         uint32_t _ptr_server_name;
3647         TALLOC_CTX *_mem_save_server_name_0;
3648         uint32_t _ptr_user_name;
3649         TALLOC_CTX *_mem_save_user_name_0;
3650         uint32_t _ptr_document_name;
3651         TALLOC_CTX *_mem_save_document_name_0;
3652         uint32_t _ptr_notify_name;
3653         TALLOC_CTX *_mem_save_notify_name_0;
3654         uint32_t _ptr_data_type;
3655         TALLOC_CTX *_mem_save_data_type_0;
3656         uint32_t _ptr_print_processor;
3657         TALLOC_CTX *_mem_save_print_processor_0;
3658         uint32_t _ptr_parameters;
3659         TALLOC_CTX *_mem_save_parameters_0;
3660         uint32_t _ptr_driver_name;
3661         TALLOC_CTX *_mem_save_driver_name_0;
3662         uint32_t _ptr_devmode;
3663         TALLOC_CTX *_mem_save_devmode_0;
3664         uint32_t _ptr_text_status;
3665         TALLOC_CTX *_mem_save_text_status_0;
3666         uint32_t _ptr_secdesc;
3667         TALLOC_CTX *_mem_save_secdesc_0;
3668         if (ndr_flags & NDR_SCALARS) {
3669                 NDR_CHECK(ndr_pull_align(ndr, 5));
3670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3671                 {
3672                         uint32_t _flags_save_string = ndr->flags;
3673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3675                         if (_ptr_printer_name) {
3676                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3678                         } else {
3679                                 r->printer_name = NULL;
3680                         }
3681                         ndr->flags = _flags_save_string;
3682                 }
3683                 {
3684                         uint32_t _flags_save_string = ndr->flags;
3685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3687                         if (_ptr_server_name) {
3688                                 NDR_PULL_ALLOC(ndr, r->server_name);
3689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3690                         } else {
3691                                 r->server_name = NULL;
3692                         }
3693                         ndr->flags = _flags_save_string;
3694                 }
3695                 {
3696                         uint32_t _flags_save_string = ndr->flags;
3697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3699                         if (_ptr_user_name) {
3700                                 NDR_PULL_ALLOC(ndr, r->user_name);
3701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3702                         } else {
3703                                 r->user_name = NULL;
3704                         }
3705                         ndr->flags = _flags_save_string;
3706                 }
3707                 {
3708                         uint32_t _flags_save_string = ndr->flags;
3709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3710                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3711                         if (_ptr_document_name) {
3712                                 NDR_PULL_ALLOC(ndr, r->document_name);
3713                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3714                         } else {
3715                                 r->document_name = NULL;
3716                         }
3717                         ndr->flags = _flags_save_string;
3718                 }
3719                 {
3720                         uint32_t _flags_save_string = ndr->flags;
3721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3722                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3723                         if (_ptr_notify_name) {
3724                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3725                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3726                         } else {
3727                                 r->notify_name = NULL;
3728                         }
3729                         ndr->flags = _flags_save_string;
3730                 }
3731                 {
3732                         uint32_t _flags_save_string = ndr->flags;
3733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3734                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3735                         if (_ptr_data_type) {
3736                                 NDR_PULL_ALLOC(ndr, r->data_type);
3737                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3738                         } else {
3739                                 r->data_type = NULL;
3740                         }
3741                         ndr->flags = _flags_save_string;
3742                 }
3743                 {
3744                         uint32_t _flags_save_string = ndr->flags;
3745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3746                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3747                         if (_ptr_print_processor) {
3748                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3749                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3750                         } else {
3751                                 r->print_processor = NULL;
3752                         }
3753                         ndr->flags = _flags_save_string;
3754                 }
3755                 {
3756                         uint32_t _flags_save_string = ndr->flags;
3757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3758                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3759                         if (_ptr_parameters) {
3760                                 NDR_PULL_ALLOC(ndr, r->parameters);
3761                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3762                         } else {
3763                                 r->parameters = NULL;
3764                         }
3765                         ndr->flags = _flags_save_string;
3766                 }
3767                 {
3768                         uint32_t _flags_save_string = ndr->flags;
3769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3770                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3771                         if (_ptr_driver_name) {
3772                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3773                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3774                         } else {
3775                                 r->driver_name = NULL;
3776                         }
3777                         ndr->flags = _flags_save_string;
3778                 }
3779                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3780                 if (_ptr_devmode) {
3781                         NDR_PULL_ALLOC(ndr, r->devmode);
3782                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3783                 } else {
3784                         r->devmode = NULL;
3785                 }
3786                 {
3787                         uint32_t _flags_save_string = ndr->flags;
3788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3789                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3790                         if (_ptr_text_status) {
3791                                 NDR_PULL_ALLOC(ndr, r->text_status);
3792                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3793                         } else {
3794                                 r->text_status = NULL;
3795                         }
3796                         ndr->flags = _flags_save_string;
3797                 }
3798                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3799                 if (_ptr_secdesc) {
3800                         NDR_PULL_ALLOC(ndr, r->secdesc);
3801                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3802                 } else {
3803                         r->secdesc = NULL;
3804                 }
3805                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3807                 if (r->priority > 99) {
3808                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3809                 }
3810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3815                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3818                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3819         }
3820         if (ndr_flags & NDR_BUFFERS) {
3821                 {
3822                         uint32_t _flags_save_string = ndr->flags;
3823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3824                         if (r->printer_name) {
3825                                 uint32_t _relative_save_offset;
3826                                 _relative_save_offset = ndr->offset;
3827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3828                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3829                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3832                                 ndr->offset = _relative_save_offset;
3833                         }
3834                         ndr->flags = _flags_save_string;
3835                 }
3836                 {
3837                         uint32_t _flags_save_string = ndr->flags;
3838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3839                         if (r->server_name) {
3840                                 uint32_t _relative_save_offset;
3841                                 _relative_save_offset = ndr->offset;
3842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3843                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3844                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3847                                 ndr->offset = _relative_save_offset;
3848                         }
3849                         ndr->flags = _flags_save_string;
3850                 }
3851                 {
3852                         uint32_t _flags_save_string = ndr->flags;
3853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3854                         if (r->user_name) {
3855                                 uint32_t _relative_save_offset;
3856                                 _relative_save_offset = ndr->offset;
3857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3858                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3859                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3862                                 ndr->offset = _relative_save_offset;
3863                         }
3864                         ndr->flags = _flags_save_string;
3865                 }
3866                 {
3867                         uint32_t _flags_save_string = ndr->flags;
3868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3869                         if (r->document_name) {
3870                                 uint32_t _relative_save_offset;
3871                                 _relative_save_offset = ndr->offset;
3872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3873                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3874                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3877                                 ndr->offset = _relative_save_offset;
3878                         }
3879                         ndr->flags = _flags_save_string;
3880                 }
3881                 {
3882                         uint32_t _flags_save_string = ndr->flags;
3883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3884                         if (r->notify_name) {
3885                                 uint32_t _relative_save_offset;
3886                                 _relative_save_offset = ndr->offset;
3887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3888                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3889                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3892                                 ndr->offset = _relative_save_offset;
3893                         }
3894                         ndr->flags = _flags_save_string;
3895                 }
3896                 {
3897                         uint32_t _flags_save_string = ndr->flags;
3898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3899                         if (r->data_type) {
3900                                 uint32_t _relative_save_offset;
3901                                 _relative_save_offset = ndr->offset;
3902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3903                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3904                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3907                                 ndr->offset = _relative_save_offset;
3908                         }
3909                         ndr->flags = _flags_save_string;
3910                 }
3911                 {
3912                         uint32_t _flags_save_string = ndr->flags;
3913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3914                         if (r->print_processor) {
3915                                 uint32_t _relative_save_offset;
3916                                 _relative_save_offset = ndr->offset;
3917                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3918                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3919                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3920                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3921                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3922                                 ndr->offset = _relative_save_offset;
3923                         }
3924                         ndr->flags = _flags_save_string;
3925                 }
3926                 {
3927                         uint32_t _flags_save_string = ndr->flags;
3928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3929                         if (r->parameters) {
3930                                 uint32_t _relative_save_offset;
3931                                 _relative_save_offset = ndr->offset;
3932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3933                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3934                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3937                                 ndr->offset = _relative_save_offset;
3938                         }
3939                         ndr->flags = _flags_save_string;
3940                 }
3941                 {
3942                         uint32_t _flags_save_string = ndr->flags;
3943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3944                         if (r->driver_name) {
3945                                 uint32_t _relative_save_offset;
3946                                 _relative_save_offset = ndr->offset;
3947                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3948                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3949                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3950                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3951                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3952                                 ndr->offset = _relative_save_offset;
3953                         }
3954                         ndr->flags = _flags_save_string;
3955                 }
3956                 if (r->devmode) {
3957                         uint32_t _relative_save_offset;
3958                         _relative_save_offset = ndr->offset;
3959                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3960                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3961                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3962                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3964                         ndr->offset = _relative_save_offset;
3965                 }
3966                 {
3967                         uint32_t _flags_save_string = ndr->flags;
3968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3969                         if (r->text_status) {
3970                                 uint32_t _relative_save_offset;
3971                                 _relative_save_offset = ndr->offset;
3972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3973                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3974                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3977                                 ndr->offset = _relative_save_offset;
3978                         }
3979                         ndr->flags = _flags_save_string;
3980                 }
3981                 if (r->secdesc) {
3982                         uint32_t _relative_save_offset;
3983                         _relative_save_offset = ndr->offset;
3984                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3985                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3986                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3987                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3989                         ndr->offset = _relative_save_offset;
3990                 }
3991         }
3992         return NDR_ERR_SUCCESS;
3993 }
3994
3995 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3996 {
3997         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3998         ndr->depth++;
3999         ndr_print_uint32(ndr, "job_id", r->job_id);
4000         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4001         ndr->depth++;
4002         if (r->printer_name) {
4003                 ndr_print_string(ndr, "printer_name", r->printer_name);
4004         }
4005         ndr->depth--;
4006         ndr_print_ptr(ndr, "server_name", r->server_name);
4007         ndr->depth++;
4008         if (r->server_name) {
4009                 ndr_print_string(ndr, "server_name", r->server_name);
4010         }
4011         ndr->depth--;
4012         ndr_print_ptr(ndr, "user_name", r->user_name);
4013         ndr->depth++;
4014         if (r->user_name) {
4015                 ndr_print_string(ndr, "user_name", r->user_name);
4016         }
4017         ndr->depth--;
4018         ndr_print_ptr(ndr, "document_name", r->document_name);
4019         ndr->depth++;
4020         if (r->document_name) {
4021                 ndr_print_string(ndr, "document_name", r->document_name);
4022         }
4023         ndr->depth--;
4024         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4025         ndr->depth++;
4026         if (r->notify_name) {
4027                 ndr_print_string(ndr, "notify_name", r->notify_name);
4028         }
4029         ndr->depth--;
4030         ndr_print_ptr(ndr, "data_type", r->data_type);
4031         ndr->depth++;
4032         if (r->data_type) {
4033                 ndr_print_string(ndr, "data_type", r->data_type);
4034         }
4035         ndr->depth--;
4036         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4037         ndr->depth++;
4038         if (r->print_processor) {
4039                 ndr_print_string(ndr, "print_processor", r->print_processor);
4040         }
4041         ndr->depth--;
4042         ndr_print_ptr(ndr, "parameters", r->parameters);
4043         ndr->depth++;
4044         if (r->parameters) {
4045                 ndr_print_string(ndr, "parameters", r->parameters);
4046         }
4047         ndr->depth--;
4048         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4049         ndr->depth++;
4050         if (r->driver_name) {
4051                 ndr_print_string(ndr, "driver_name", r->driver_name);
4052         }
4053         ndr->depth--;
4054         ndr_print_ptr(ndr, "devmode", r->devmode);
4055         ndr->depth++;
4056         if (r->devmode) {
4057                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4058         }
4059         ndr->depth--;
4060         ndr_print_ptr(ndr, "text_status", r->text_status);
4061         ndr->depth++;
4062         if (r->text_status) {
4063                 ndr_print_string(ndr, "text_status", r->text_status);
4064         }
4065         ndr->depth--;
4066         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4067         ndr->depth++;
4068         if (r->secdesc) {
4069                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4070         }
4071         ndr->depth--;
4072         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4073         ndr_print_uint32(ndr, "priority", r->priority);
4074         ndr_print_uint32(ndr, "position", r->position);
4075         ndr_print_uint32(ndr, "start_time", r->start_time);
4076         ndr_print_uint32(ndr, "until_time", r->until_time);
4077         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4078         ndr_print_uint32(ndr, "size", r->size);
4079         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4080         ndr_print_uint32(ndr, "time", r->time);
4081         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4082         ndr->depth--;
4083 }
4084
4085 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4086 {
4087         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4088 }
4089
4090 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4091 {
4092         if (ndr_flags & NDR_SCALARS) {
4093                 NDR_CHECK(ndr_push_align(ndr, 4));
4094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4097                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4098         }
4099         if (ndr_flags & NDR_BUFFERS) {
4100         }
4101         return NDR_ERR_SUCCESS;
4102 }
4103
4104 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4105 {
4106         if (ndr_flags & NDR_SCALARS) {
4107                 NDR_CHECK(ndr_pull_align(ndr, 4));
4108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4111                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4112         }
4113         if (ndr_flags & NDR_BUFFERS) {
4114         }
4115         return NDR_ERR_SUCCESS;
4116 }
4117
4118 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4119 {
4120         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4121         ndr->depth++;
4122         ndr_print_uint32(ndr, "job_id", r->job_id);
4123         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4124         ndr_print_uint32(ndr, "reserved", r->reserved);
4125         ndr->depth--;
4126 }
4127
4128 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4129 {
4130         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4131 }
4132
4133 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4134 {
4135         if (ndr_flags & NDR_SCALARS) {
4136                 NDR_CHECK(ndr_push_align(ndr, 5));
4137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4138                 {
4139                         uint32_t _flags_save_string = ndr->flags;
4140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4141                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4142                         ndr->flags = _flags_save_string;
4143                 }
4144                 {
4145                         uint32_t _flags_save_string = ndr->flags;
4146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4147                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4148                         ndr->flags = _flags_save_string;
4149                 }
4150                 {
4151                         uint32_t _flags_save_string = ndr->flags;
4152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4153                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4154                         ndr->flags = _flags_save_string;
4155                 }
4156                 {
4157                         uint32_t _flags_save_string = ndr->flags;
4158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4159                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4160                         ndr->flags = _flags_save_string;
4161                 }
4162                 {
4163                         uint32_t _flags_save_string = ndr->flags;
4164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4165                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4166                         ndr->flags = _flags_save_string;
4167                 }
4168                 {
4169                         uint32_t _flags_save_string = ndr->flags;
4170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4171                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4172                         ndr->flags = _flags_save_string;
4173                 }
4174                 {
4175                         uint32_t _flags_save_string = ndr->flags;
4176                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4177                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4178                         ndr->flags = _flags_save_string;
4179                 }
4180                 {
4181                         uint32_t _flags_save_string = ndr->flags;
4182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4183                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4184                         ndr->flags = _flags_save_string;
4185                 }
4186                 {
4187                         uint32_t _flags_save_string = ndr->flags;
4188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4189                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4190                         ndr->flags = _flags_save_string;
4191                 }
4192                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4193                 {
4194                         uint32_t _flags_save_string = ndr->flags;
4195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4196                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4197                         ndr->flags = _flags_save_string;
4198                 }
4199                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4200                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4207                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4211                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4212         }
4213         if (ndr_flags & NDR_BUFFERS) {
4214                 {
4215                         uint32_t _flags_save_string = ndr->flags;
4216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4217                         if (r->printer_name) {
4218                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
4219                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4220                         }
4221                         ndr->flags = _flags_save_string;
4222                 }
4223                 {
4224                         uint32_t _flags_save_string = ndr->flags;
4225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4226                         if (r->server_name) {
4227                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
4228                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4229                         }
4230                         ndr->flags = _flags_save_string;
4231                 }
4232                 {
4233                         uint32_t _flags_save_string = ndr->flags;
4234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4235                         if (r->user_name) {
4236                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
4237                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4238                         }
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                         if (r->document_name) {
4245                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
4246                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4247                         }
4248                         ndr->flags = _flags_save_string;
4249                 }
4250                 {
4251                         uint32_t _flags_save_string = ndr->flags;
4252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4253                         if (r->notify_name) {
4254                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
4255                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4256                         }
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                         if (r->data_type) {
4263                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
4264                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4265                         }
4266                         ndr->flags = _flags_save_string;
4267                 }
4268                 {
4269                         uint32_t _flags_save_string = ndr->flags;
4270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4271                         if (r->print_processor) {
4272                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
4273                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4274                         }
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                         if (r->parameters) {
4281                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
4282                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4283                         }
4284                         ndr->flags = _flags_save_string;
4285                 }
4286                 {
4287                         uint32_t _flags_save_string = ndr->flags;
4288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4289                         if (r->driver_name) {
4290                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4291                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4292                         }
4293                         ndr->flags = _flags_save_string;
4294                 }
4295                 if (r->devmode) {
4296                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
4297                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4298                 }
4299                 {
4300                         uint32_t _flags_save_string = ndr->flags;
4301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4302                         if (r->text_status) {
4303                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
4304                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4305                         }
4306                         ndr->flags = _flags_save_string;
4307                 }
4308                 if (r->secdesc) {
4309                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
4310                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4311                 }
4312         }
4313         return NDR_ERR_SUCCESS;
4314 }
4315
4316 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4317 {
4318         uint32_t _ptr_printer_name;
4319         TALLOC_CTX *_mem_save_printer_name_0;
4320         uint32_t _ptr_server_name;
4321         TALLOC_CTX *_mem_save_server_name_0;
4322         uint32_t _ptr_user_name;
4323         TALLOC_CTX *_mem_save_user_name_0;
4324         uint32_t _ptr_document_name;
4325         TALLOC_CTX *_mem_save_document_name_0;
4326         uint32_t _ptr_notify_name;
4327         TALLOC_CTX *_mem_save_notify_name_0;
4328         uint32_t _ptr_data_type;
4329         TALLOC_CTX *_mem_save_data_type_0;
4330         uint32_t _ptr_print_processor;
4331         TALLOC_CTX *_mem_save_print_processor_0;
4332         uint32_t _ptr_parameters;
4333         TALLOC_CTX *_mem_save_parameters_0;
4334         uint32_t _ptr_driver_name;
4335         TALLOC_CTX *_mem_save_driver_name_0;
4336         uint32_t _ptr_devmode;
4337         TALLOC_CTX *_mem_save_devmode_0;
4338         uint32_t _ptr_text_status;
4339         TALLOC_CTX *_mem_save_text_status_0;
4340         uint32_t _ptr_secdesc;
4341         TALLOC_CTX *_mem_save_secdesc_0;
4342         if (ndr_flags & NDR_SCALARS) {
4343                 NDR_CHECK(ndr_pull_align(ndr, 5));
4344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4345                 {
4346                         uint32_t _flags_save_string = ndr->flags;
4347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4348                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4349                         if (_ptr_printer_name) {
4350                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4351                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4352                         } else {
4353                                 r->printer_name = NULL;
4354                         }
4355                         ndr->flags = _flags_save_string;
4356                 }
4357                 {
4358                         uint32_t _flags_save_string = ndr->flags;
4359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4360                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4361                         if (_ptr_server_name) {
4362                                 NDR_PULL_ALLOC(ndr, r->server_name);
4363                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4364                         } else {
4365                                 r->server_name = NULL;
4366                         }
4367                         ndr->flags = _flags_save_string;
4368                 }
4369                 {
4370                         uint32_t _flags_save_string = ndr->flags;
4371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4372                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4373                         if (_ptr_user_name) {
4374                                 NDR_PULL_ALLOC(ndr, r->user_name);
4375                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4376                         } else {
4377                                 r->user_name = NULL;
4378                         }
4379                         ndr->flags = _flags_save_string;
4380                 }
4381                 {
4382                         uint32_t _flags_save_string = ndr->flags;
4383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4384                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4385                         if (_ptr_document_name) {
4386                                 NDR_PULL_ALLOC(ndr, r->document_name);
4387                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4388                         } else {
4389                                 r->document_name = NULL;
4390                         }
4391                         ndr->flags = _flags_save_string;
4392                 }
4393                 {
4394                         uint32_t _flags_save_string = ndr->flags;
4395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4396                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4397                         if (_ptr_notify_name) {
4398                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4399                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4400                         } else {
4401                                 r->notify_name = NULL;
4402                         }
4403                         ndr->flags = _flags_save_string;
4404                 }
4405                 {
4406                         uint32_t _flags_save_string = ndr->flags;
4407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4408                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4409                         if (_ptr_data_type) {
4410                                 NDR_PULL_ALLOC(ndr, r->data_type);
4411                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4412                         } else {
4413                                 r->data_type = NULL;
4414                         }
4415                         ndr->flags = _flags_save_string;
4416                 }
4417                 {
4418                         uint32_t _flags_save_string = ndr->flags;
4419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4420                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4421                         if (_ptr_print_processor) {
4422                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4423                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4424                         } else {
4425                                 r->print_processor = NULL;
4426                         }
4427                         ndr->flags = _flags_save_string;
4428                 }
4429                 {
4430                         uint32_t _flags_save_string = ndr->flags;
4431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4432                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4433                         if (_ptr_parameters) {
4434                                 NDR_PULL_ALLOC(ndr, r->parameters);
4435                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4436                         } else {
4437                                 r->parameters = NULL;
4438                         }
4439                         ndr->flags = _flags_save_string;
4440                 }
4441                 {
4442                         uint32_t _flags_save_string = ndr->flags;
4443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4444                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4445                         if (_ptr_driver_name) {
4446                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4447                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4448                         } else {
4449                                 r->driver_name = NULL;
4450                         }
4451                         ndr->flags = _flags_save_string;
4452                 }
4453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4454                 if (_ptr_devmode) {
4455                         NDR_PULL_ALLOC(ndr, r->devmode);
4456                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4457                 } else {
4458                         r->devmode = NULL;
4459                 }
4460                 {
4461                         uint32_t _flags_save_string = ndr->flags;
4462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4463                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4464                         if (_ptr_text_status) {
4465                                 NDR_PULL_ALLOC(ndr, r->text_status);
4466                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4467                         } else {
4468                                 r->text_status = NULL;
4469                         }
4470                         ndr->flags = _flags_save_string;
4471                 }
4472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4473                 if (_ptr_secdesc) {
4474                         NDR_PULL_ALLOC(ndr, r->secdesc);
4475                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4476                 } else {
4477                         r->secdesc = NULL;
4478                 }
4479                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4481                 if (r->priority > 99) {
4482                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4483                 }
4484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4489                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4493                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4494         }
4495         if (ndr_flags & NDR_BUFFERS) {
4496                 {
4497                         uint32_t _flags_save_string = ndr->flags;
4498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4499                         if (r->printer_name) {
4500                                 uint32_t _relative_save_offset;
4501                                 _relative_save_offset = ndr->offset;
4502                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4503                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4504                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4505                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4506                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4507                                 ndr->offset = _relative_save_offset;
4508                         }
4509                         ndr->flags = _flags_save_string;
4510                 }
4511                 {
4512                         uint32_t _flags_save_string = ndr->flags;
4513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4514                         if (r->server_name) {
4515                                 uint32_t _relative_save_offset;
4516                                 _relative_save_offset = ndr->offset;
4517                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4518                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4519                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4520                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4521                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4522                                 ndr->offset = _relative_save_offset;
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                         if (r->user_name) {
4530                                 uint32_t _relative_save_offset;
4531                                 _relative_save_offset = ndr->offset;
4532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4533                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4534                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4537                                 ndr->offset = _relative_save_offset;
4538                         }
4539                         ndr->flags = _flags_save_string;
4540                 }
4541                 {
4542                         uint32_t _flags_save_string = ndr->flags;
4543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4544                         if (r->document_name) {
4545                                 uint32_t _relative_save_offset;
4546                                 _relative_save_offset = ndr->offset;
4547                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4548                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4549                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4550                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4551                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4552                                 ndr->offset = _relative_save_offset;
4553                         }
4554                         ndr->flags = _flags_save_string;
4555                 }
4556                 {
4557                         uint32_t _flags_save_string = ndr->flags;
4558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4559                         if (r->notify_name) {
4560                                 uint32_t _relative_save_offset;
4561                                 _relative_save_offset = ndr->offset;
4562                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4563                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4564                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4565                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4566                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4567                                 ndr->offset = _relative_save_offset;
4568                         }
4569                         ndr->flags = _flags_save_string;
4570                 }
4571                 {
4572                         uint32_t _flags_save_string = ndr->flags;
4573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4574                         if (r->data_type) {
4575                                 uint32_t _relative_save_offset;
4576                                 _relative_save_offset = ndr->offset;
4577                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4578                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4579                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4580                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4581                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4582                                 ndr->offset = _relative_save_offset;
4583                         }
4584                         ndr->flags = _flags_save_string;
4585                 }
4586                 {
4587                         uint32_t _flags_save_string = ndr->flags;
4588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4589                         if (r->print_processor) {
4590                                 uint32_t _relative_save_offset;
4591                                 _relative_save_offset = ndr->offset;
4592                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4593                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4594                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4595                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4596                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4597                                 ndr->offset = _relative_save_offset;
4598                         }
4599                         ndr->flags = _flags_save_string;
4600                 }
4601                 {
4602                         uint32_t _flags_save_string = ndr->flags;
4603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4604                         if (r->parameters) {
4605                                 uint32_t _relative_save_offset;
4606                                 _relative_save_offset = ndr->offset;
4607                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4608                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4609                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4610                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4611                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4612                                 ndr->offset = _relative_save_offset;
4613                         }
4614                         ndr->flags = _flags_save_string;
4615                 }
4616                 {
4617                         uint32_t _flags_save_string = ndr->flags;
4618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4619                         if (r->driver_name) {
4620                                 uint32_t _relative_save_offset;
4621                                 _relative_save_offset = ndr->offset;
4622                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4623                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4624                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4625                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4626                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4627                                 ndr->offset = _relative_save_offset;
4628                         }
4629                         ndr->flags = _flags_save_string;
4630                 }
4631                 if (r->devmode) {
4632                         uint32_t _relative_save_offset;
4633                         _relative_save_offset = ndr->offset;
4634                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4635                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4636                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4637                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4639                         ndr->offset = _relative_save_offset;
4640                 }
4641                 {
4642                         uint32_t _flags_save_string = ndr->flags;
4643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4644                         if (r->text_status) {
4645                                 uint32_t _relative_save_offset;
4646                                 _relative_save_offset = ndr->offset;
4647                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4648                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4649                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4650                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4651                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4652                                 ndr->offset = _relative_save_offset;
4653                         }
4654                         ndr->flags = _flags_save_string;
4655                 }
4656                 if (r->secdesc) {
4657                         uint32_t _relative_save_offset;
4658                         _relative_save_offset = ndr->offset;
4659                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4660                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4661                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4662                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4664                         ndr->offset = _relative_save_offset;
4665                 }
4666         }
4667         return NDR_ERR_SUCCESS;
4668 }
4669
4670 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4671 {
4672         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4673         ndr->depth++;
4674         ndr_print_uint32(ndr, "job_id", r->job_id);
4675         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4676         ndr->depth++;
4677         if (r->printer_name) {
4678                 ndr_print_string(ndr, "printer_name", r->printer_name);
4679         }
4680         ndr->depth--;
4681         ndr_print_ptr(ndr, "server_name", r->server_name);
4682         ndr->depth++;
4683         if (r->server_name) {
4684                 ndr_print_string(ndr, "server_name", r->server_name);
4685         }
4686         ndr->depth--;
4687         ndr_print_ptr(ndr, "user_name", r->user_name);
4688         ndr->depth++;
4689         if (r->user_name) {
4690                 ndr_print_string(ndr, "user_name", r->user_name);
4691         }
4692         ndr->depth--;
4693         ndr_print_ptr(ndr, "document_name", r->document_name);
4694         ndr->depth++;
4695         if (r->document_name) {
4696                 ndr_print_string(ndr, "document_name", r->document_name);
4697         }
4698         ndr->depth--;
4699         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4700         ndr->depth++;
4701         if (r->notify_name) {
4702                 ndr_print_string(ndr, "notify_name", r->notify_name);
4703         }
4704         ndr->depth--;
4705         ndr_print_ptr(ndr, "data_type", r->data_type);
4706         ndr->depth++;
4707         if (r->data_type) {
4708                 ndr_print_string(ndr, "data_type", r->data_type);
4709         }
4710         ndr->depth--;
4711         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4712         ndr->depth++;
4713         if (r->print_processor) {
4714                 ndr_print_string(ndr, "print_processor", r->print_processor);
4715         }
4716         ndr->depth--;
4717         ndr_print_ptr(ndr, "parameters", r->parameters);
4718         ndr->depth++;
4719         if (r->parameters) {
4720                 ndr_print_string(ndr, "parameters", r->parameters);
4721         }
4722         ndr->depth--;
4723         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4724         ndr->depth++;
4725         if (r->driver_name) {
4726                 ndr_print_string(ndr, "driver_name", r->driver_name);
4727         }
4728         ndr->depth--;
4729         ndr_print_ptr(ndr, "devmode", r->devmode);
4730         ndr->depth++;
4731         if (r->devmode) {
4732                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4733         }
4734         ndr->depth--;
4735         ndr_print_ptr(ndr, "text_status", r->text_status);
4736         ndr->depth++;
4737         if (r->text_status) {
4738                 ndr_print_string(ndr, "text_status", r->text_status);
4739         }
4740         ndr->depth--;
4741         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4742         ndr->depth++;
4743         if (r->secdesc) {
4744                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4745         }
4746         ndr->depth--;
4747         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4748         ndr_print_uint32(ndr, "priority", r->priority);
4749         ndr_print_uint32(ndr, "position", r->position);
4750         ndr_print_uint32(ndr, "start_time", r->start_time);
4751         ndr_print_uint32(ndr, "until_time", r->until_time);
4752         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4753         ndr_print_uint32(ndr, "size", r->size);
4754         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4755         ndr_print_uint32(ndr, "time", r->time);
4756         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4757         ndr_print_uint32(ndr, "size_high", r->size_high);
4758         ndr->depth--;
4759 }
4760
4761 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4762 {
4763         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4764 }
4765
4766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4767 {
4768         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4769         if (ndr_flags & NDR_SCALARS) {
4770                 int level = ndr_push_get_switch_value(ndr, r);
4771                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4772                 switch (level) {
4773                         case 1: {
4774                                 NDR_CHECK(ndr_push_align(ndr, 5));
4775                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4776                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4777                         break; }
4778
4779                         case 2: {
4780                                 NDR_CHECK(ndr_push_align(ndr, 5));
4781                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4782                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4783                         break; }
4784
4785                         case 3: {
4786                                 NDR_CHECK(ndr_push_align(ndr, 4));
4787                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4788                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4789                         break; }
4790
4791                         case 4: {
4792                                 NDR_CHECK(ndr_push_align(ndr, 5));
4793                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4794                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4795                         break; }
4796
4797                         default: {
4798                         break; }
4799
4800                 }
4801         }
4802         if (ndr_flags & NDR_BUFFERS) {
4803                 int level = ndr_push_get_switch_value(ndr, r);
4804                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4805                 switch (level) {
4806                         case 1:
4807                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4808                         break;
4809
4810                         case 2:
4811                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4812                         break;
4813
4814                         case 3:
4815                         break;
4816
4817                         case 4:
4818                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4819                         break;
4820
4821                         default:
4822                         break;
4823
4824                 }
4825         }
4826         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4827         return NDR_ERR_SUCCESS;
4828 }
4829
4830 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4831 {
4832         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4833         int level;
4834         level = ndr_pull_get_switch_value(ndr, r);
4835         if (ndr_flags & NDR_SCALARS) {
4836                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4837                 switch (level) {
4838                         case 1: {
4839                                 NDR_CHECK(ndr_pull_align(ndr, 5));
4840                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4841                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4842                         break; }
4843
4844                         case 2: {
4845                                 NDR_CHECK(ndr_pull_align(ndr, 5));
4846                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4847                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4848                         break; }
4849
4850                         case 3: {
4851                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4852                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4853                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4854                         break; }
4855
4856                         case 4: {
4857                                 NDR_CHECK(ndr_pull_align(ndr, 5));
4858                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4859                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4860                         break; }
4861
4862                         default: {
4863                         break; }
4864
4865                 }
4866         }
4867         if (ndr_flags & NDR_BUFFERS) {
4868                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4869                 switch (level) {
4870                         case 1:
4871                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4872                         break;
4873
4874                         case 2:
4875                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4876                         break;
4877
4878                         case 3:
4879                         break;
4880
4881                         case 4:
4882                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4883                         break;
4884
4885                         default:
4886                         break;
4887
4888                 }
4889         }
4890         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4891         return NDR_ERR_SUCCESS;
4892 }
4893
4894 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4895 {
4896         int level;
4897         level = ndr_print_get_switch_value(ndr, r);
4898         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4899         switch (level) {
4900                 case 1:
4901                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4902                 break;
4903
4904                 case 2:
4905                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4906                 break;
4907
4908                 case 3:
4909                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4910                 break;
4911
4912                 case 4:
4913                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4914                 break;
4915
4916                 default:
4917                 break;
4918
4919         }
4920 }
4921
4922 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4923 {
4924         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4925 }
4926
4927 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4928 {
4929         if (ndr_flags & NDR_SCALARS) {
4930                 NDR_CHECK(ndr_push_align(ndr, 5));
4931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4934                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4936                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4938                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4943                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4944                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4945         }
4946         if (ndr_flags & NDR_BUFFERS) {
4947                 if (r->printer_name) {
4948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4952                 }
4953                 if (r->server_name) {
4954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4958                 }
4959                 if (r->user_name) {
4960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4961                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4962                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4964                 }
4965                 if (r->document_name) {
4966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4968                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4970                 }
4971                 if (r->data_type) {
4972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4976                 }
4977                 if (r->text_status) {
4978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4980                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4981                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4982                 }
4983         }
4984         return NDR_ERR_SUCCESS;
4985 }
4986
4987 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4988 {
4989         uint32_t _ptr_printer_name;
4990         TALLOC_CTX *_mem_save_printer_name_0;
4991         uint32_t _ptr_server_name;
4992         TALLOC_CTX *_mem_save_server_name_0;
4993         uint32_t _ptr_user_name;
4994         TALLOC_CTX *_mem_save_user_name_0;
4995         uint32_t _ptr_document_name;
4996         TALLOC_CTX *_mem_save_document_name_0;
4997         uint32_t _ptr_data_type;
4998         TALLOC_CTX *_mem_save_data_type_0;
4999         uint32_t _ptr_text_status;
5000         TALLOC_CTX *_mem_save_text_status_0;
5001         if (ndr_flags & NDR_SCALARS) {
5002                 NDR_CHECK(ndr_pull_align(ndr, 5));
5003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5004                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5005                 if (_ptr_printer_name) {
5006                         NDR_PULL_ALLOC(ndr, r->printer_name);
5007                 } else {
5008                         r->printer_name = NULL;
5009                 }
5010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5011                 if (_ptr_server_name) {
5012                         NDR_PULL_ALLOC(ndr, r->server_name);
5013                 } else {
5014                         r->server_name = NULL;
5015                 }
5016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5017                 if (_ptr_user_name) {
5018                         NDR_PULL_ALLOC(ndr, r->user_name);
5019                 } else {
5020                         r->user_name = NULL;
5021                 }
5022                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5023                 if (_ptr_document_name) {
5024                         NDR_PULL_ALLOC(ndr, r->document_name);
5025                 } else {
5026                         r->document_name = NULL;
5027                 }
5028                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5029                 if (_ptr_data_type) {
5030                         NDR_PULL_ALLOC(ndr, r->data_type);
5031                 } else {
5032                         r->data_type = NULL;
5033                 }
5034                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5035                 if (_ptr_text_status) {
5036                         NDR_PULL_ALLOC(ndr, r->text_status);
5037                 } else {
5038                         r->text_status = NULL;
5039                 }
5040                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5042                 if (r->priority > 99) {
5043                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5044                 }
5045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5048                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5049                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5050         }
5051         if (ndr_flags & NDR_BUFFERS) {
5052                 if (r->printer_name) {
5053                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5054                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5057                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5058                                 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));
5059                         }
5060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5063                 }
5064                 if (r->server_name) {
5065                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5066                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5069                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5070                                 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));
5071                         }
5072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5075                 }
5076                 if (r->user_name) {
5077                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5078                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5081                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5082                                 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));
5083                         }
5084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5087                 }
5088                 if (r->document_name) {
5089                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5090                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5091                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5092                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5093                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5094                                 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));
5095                         }
5096                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5097                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5099                 }
5100                 if (r->data_type) {
5101                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5102                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5105                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5106                                 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));
5107                         }
5108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5109                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5111                 }
5112                 if (r->text_status) {
5113                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5114                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5115                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5116                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5117                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5118                                 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));
5119                         }
5120                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5121                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5123                 }
5124         }
5125         return NDR_ERR_SUCCESS;
5126 }
5127
5128 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5129 {
5130         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5131         ndr->depth++;
5132         ndr_print_uint32(ndr, "job_id", r->job_id);
5133         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5134         ndr->depth++;
5135         if (r->printer_name) {
5136                 ndr_print_string(ndr, "printer_name", r->printer_name);
5137         }
5138         ndr->depth--;
5139         ndr_print_ptr(ndr, "server_name", r->server_name);
5140         ndr->depth++;
5141         if (r->server_name) {
5142                 ndr_print_string(ndr, "server_name", r->server_name);
5143         }
5144         ndr->depth--;
5145         ndr_print_ptr(ndr, "user_name", r->user_name);
5146         ndr->depth++;
5147         if (r->user_name) {
5148                 ndr_print_string(ndr, "user_name", r->user_name);
5149         }
5150         ndr->depth--;
5151         ndr_print_ptr(ndr, "document_name", r->document_name);
5152         ndr->depth++;
5153         if (r->document_name) {
5154                 ndr_print_string(ndr, "document_name", r->document_name);
5155         }
5156         ndr->depth--;
5157         ndr_print_ptr(ndr, "data_type", r->data_type);
5158         ndr->depth++;
5159         if (r->data_type) {
5160                 ndr_print_string(ndr, "data_type", r->data_type);
5161         }
5162         ndr->depth--;
5163         ndr_print_ptr(ndr, "text_status", r->text_status);
5164         ndr->depth++;
5165         if (r->text_status) {
5166                 ndr_print_string(ndr, "text_status", r->text_status);
5167         }
5168         ndr->depth--;
5169         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5170         ndr_print_uint32(ndr, "priority", r->priority);
5171         ndr_print_uint32(ndr, "position", r->position);
5172         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5173         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5174         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5175         ndr->depth--;
5176 }
5177
5178 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5179 {
5180         if (ndr_flags & NDR_SCALARS) {
5181                 NDR_CHECK(ndr_push_align(ndr, 5));
5182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5190                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5195                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5202                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5205                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5206         }
5207         if (ndr_flags & NDR_BUFFERS) {
5208                 if (r->printer_name) {
5209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5212                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5213                 }
5214                 if (r->server_name) {
5215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5218                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5219                 }
5220                 if (r->user_name) {
5221                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5222                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5223                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5224                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5225                 }
5226                 if (r->document_name) {
5227                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5228                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5229                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5230                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5231                 }
5232                 if (r->notify_name) {
5233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5234                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5235                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5236                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5237                 }
5238                 if (r->data_type) {
5239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5242                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5243                 }
5244                 if (r->print_processor) {
5245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5246                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5248                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5249                 }
5250                 if (r->parameters) {
5251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5254                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5255                 }
5256                 if (r->driver_name) {
5257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5258                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5259                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5260                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5261                 }
5262                 if (r->text_status) {
5263                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5265                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5266                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5267                 }
5268         }
5269         return NDR_ERR_SUCCESS;
5270 }
5271
5272 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5273 {
5274         uint32_t _ptr_printer_name;
5275         TALLOC_CTX *_mem_save_printer_name_0;
5276         uint32_t _ptr_server_name;
5277         TALLOC_CTX *_mem_save_server_name_0;
5278         uint32_t _ptr_user_name;
5279         TALLOC_CTX *_mem_save_user_name_0;
5280         uint32_t _ptr_document_name;
5281         TALLOC_CTX *_mem_save_document_name_0;
5282         uint32_t _ptr_notify_name;
5283         TALLOC_CTX *_mem_save_notify_name_0;
5284         uint32_t _ptr_data_type;
5285         TALLOC_CTX *_mem_save_data_type_0;
5286         uint32_t _ptr_print_processor;
5287         TALLOC_CTX *_mem_save_print_processor_0;
5288         uint32_t _ptr_parameters;
5289         TALLOC_CTX *_mem_save_parameters_0;
5290         uint32_t _ptr_driver_name;
5291         TALLOC_CTX *_mem_save_driver_name_0;
5292         uint32_t _ptr_text_status;
5293         TALLOC_CTX *_mem_save_text_status_0;
5294         if (ndr_flags & NDR_SCALARS) {
5295                 NDR_CHECK(ndr_pull_align(ndr, 5));
5296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5298                 if (_ptr_printer_name) {
5299                         NDR_PULL_ALLOC(ndr, r->printer_name);
5300                 } else {
5301                         r->printer_name = NULL;
5302                 }
5303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5304                 if (_ptr_server_name) {
5305                         NDR_PULL_ALLOC(ndr, r->server_name);
5306                 } else {
5307                         r->server_name = NULL;
5308                 }
5309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5310                 if (_ptr_user_name) {
5311                         NDR_PULL_ALLOC(ndr, r->user_name);
5312                 } else {
5313                         r->user_name = NULL;
5314                 }
5315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5316                 if (_ptr_document_name) {
5317                         NDR_PULL_ALLOC(ndr, r->document_name);
5318                 } else {
5319                         r->document_name = NULL;
5320                 }
5321                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5322                 if (_ptr_notify_name) {
5323                         NDR_PULL_ALLOC(ndr, r->notify_name);
5324                 } else {
5325                         r->notify_name = NULL;
5326                 }
5327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5328                 if (_ptr_data_type) {
5329                         NDR_PULL_ALLOC(ndr, r->data_type);
5330                 } else {
5331                         r->data_type = NULL;
5332                 }
5333                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5334                 if (_ptr_print_processor) {
5335                         NDR_PULL_ALLOC(ndr, r->print_processor);
5336                 } else {
5337                         r->print_processor = NULL;
5338                 }
5339                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5340                 if (_ptr_parameters) {
5341                         NDR_PULL_ALLOC(ndr, r->parameters);
5342                 } else {
5343                         r->parameters = NULL;
5344                 }
5345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5346                 if (_ptr_driver_name) {
5347                         NDR_PULL_ALLOC(ndr, r->driver_name);
5348                 } else {
5349                         r->driver_name = NULL;
5350                 }
5351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5352                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5353                 if (_ptr_text_status) {
5354                         NDR_PULL_ALLOC(ndr, r->text_status);
5355                 } else {
5356                         r->text_status = NULL;
5357                 }
5358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5359                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5361                 if (r->priority > 99) {
5362                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5363                 }
5364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5369                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5372                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5373         }
5374         if (ndr_flags & NDR_BUFFERS) {
5375                 if (r->printer_name) {
5376                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5377                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5379                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5380                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5381                                 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));
5382                         }
5383                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5384                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5386                 }
5387                 if (r->server_name) {
5388                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5389                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5392                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5393                                 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));
5394                         }
5395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5398                 }
5399                 if (r->user_name) {
5400                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5401                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5404                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5405                                 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));
5406                         }
5407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5408                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5410                 }
5411                 if (r->document_name) {
5412                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5413                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5416                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5417                                 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));
5418                         }
5419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5422                 }
5423                 if (r->notify_name) {
5424                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5425                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5427                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5428                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5429                                 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));
5430                         }
5431                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5432                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5434                 }
5435                 if (r->data_type) {
5436                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5437                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5438                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5439                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5440                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5441                                 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));
5442                         }
5443                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5444                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5446                 }
5447                 if (r->print_processor) {
5448                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5449                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5450                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5451                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5452                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5453                                 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));
5454                         }
5455                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5456                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5457                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5458                 }
5459                 if (r->parameters) {
5460                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5461                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5462                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5463                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5464                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5465                                 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));
5466                         }
5467                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5468                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5469                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5470                 }
5471                 if (r->driver_name) {
5472                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5473                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5474                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5475                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5476                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5477                                 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));
5478                         }
5479                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5480                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5481                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5482                 }
5483                 if (r->text_status) {
5484                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5485                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5488                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5489                                 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));
5490                         }
5491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5494                 }
5495         }
5496         return NDR_ERR_SUCCESS;
5497 }
5498
5499 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5500 {
5501         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5502         ndr->depth++;
5503         ndr_print_uint32(ndr, "job_id", r->job_id);
5504         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5505         ndr->depth++;
5506         if (r->printer_name) {
5507                 ndr_print_string(ndr, "printer_name", r->printer_name);
5508         }
5509         ndr->depth--;
5510         ndr_print_ptr(ndr, "server_name", r->server_name);
5511         ndr->depth++;
5512         if (r->server_name) {
5513                 ndr_print_string(ndr, "server_name", r->server_name);
5514         }
5515         ndr->depth--;
5516         ndr_print_ptr(ndr, "user_name", r->user_name);
5517         ndr->depth++;
5518         if (r->user_name) {
5519                 ndr_print_string(ndr, "user_name", r->user_name);
5520         }
5521         ndr->depth--;
5522         ndr_print_ptr(ndr, "document_name", r->document_name);
5523         ndr->depth++;
5524         if (r->document_name) {
5525                 ndr_print_string(ndr, "document_name", r->document_name);
5526         }
5527         ndr->depth--;
5528         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5529         ndr->depth++;
5530         if (r->notify_name) {
5531                 ndr_print_string(ndr, "notify_name", r->notify_name);
5532         }
5533         ndr->depth--;
5534         ndr_print_ptr(ndr, "data_type", r->data_type);
5535         ndr->depth++;
5536         if (r->data_type) {
5537                 ndr_print_string(ndr, "data_type", r->data_type);
5538         }
5539         ndr->depth--;
5540         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5541         ndr->depth++;
5542         if (r->print_processor) {
5543                 ndr_print_string(ndr, "print_processor", r->print_processor);
5544         }
5545         ndr->depth--;
5546         ndr_print_ptr(ndr, "parameters", r->parameters);
5547         ndr->depth++;
5548         if (r->parameters) {
5549                 ndr_print_string(ndr, "parameters", r->parameters);
5550         }
5551         ndr->depth--;
5552         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5553         ndr->depth++;
5554         if (r->driver_name) {
5555                 ndr_print_string(ndr, "driver_name", r->driver_name);
5556         }
5557         ndr->depth--;
5558         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5559         ndr_print_ptr(ndr, "text_status", r->text_status);
5560         ndr->depth++;
5561         if (r->text_status) {
5562                 ndr_print_string(ndr, "text_status", r->text_status);
5563         }
5564         ndr->depth--;
5565         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5566         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5567         ndr_print_uint32(ndr, "priority", r->priority);
5568         ndr_print_uint32(ndr, "position", r->position);
5569         ndr_print_uint32(ndr, "start_time", r->start_time);
5570         ndr_print_uint32(ndr, "until_time", r->until_time);
5571         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5572         ndr_print_uint32(ndr, "size", r->size);
5573         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5574         ndr_print_uint32(ndr, "time", r->time);
5575         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5576         ndr->depth--;
5577 }
5578
5579 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5580 {
5581         if (ndr_flags & NDR_SCALARS) {
5582                 NDR_CHECK(ndr_push_align(ndr, 5));
5583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5584                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5585                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5587                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5588                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5589                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5591                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5592                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5596                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5603                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5607                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5608         }
5609         if (ndr_flags & NDR_BUFFERS) {
5610                 if (r->printer_name) {
5611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5613                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5614                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5615                 }
5616                 if (r->server_name) {
5617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5618                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5620                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5621                 }
5622                 if (r->user_name) {
5623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5626                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5627                 }
5628                 if (r->document_name) {
5629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5632                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5633                 }
5634                 if (r->notify_name) {
5635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5637                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5638                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5639                 }
5640                 if (r->data_type) {
5641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5644                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5645                 }
5646                 if (r->print_processor) {
5647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5650                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5651                 }
5652                 if (r->parameters) {
5653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5656                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5657                 }
5658                 if (r->driver_name) {
5659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5662                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5663                 }
5664                 if (r->text_status) {
5665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5668                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5669                 }
5670         }
5671         return NDR_ERR_SUCCESS;
5672 }
5673
5674 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5675 {
5676         uint32_t _ptr_printer_name;
5677         TALLOC_CTX *_mem_save_printer_name_0;
5678         uint32_t _ptr_server_name;
5679         TALLOC_CTX *_mem_save_server_name_0;
5680         uint32_t _ptr_user_name;
5681         TALLOC_CTX *_mem_save_user_name_0;
5682         uint32_t _ptr_document_name;
5683         TALLOC_CTX *_mem_save_document_name_0;
5684         uint32_t _ptr_notify_name;
5685         TALLOC_CTX *_mem_save_notify_name_0;
5686         uint32_t _ptr_data_type;
5687         TALLOC_CTX *_mem_save_data_type_0;
5688         uint32_t _ptr_print_processor;
5689         TALLOC_CTX *_mem_save_print_processor_0;
5690         uint32_t _ptr_parameters;
5691         TALLOC_CTX *_mem_save_parameters_0;
5692         uint32_t _ptr_driver_name;
5693         TALLOC_CTX *_mem_save_driver_name_0;
5694         uint32_t _ptr_text_status;
5695         TALLOC_CTX *_mem_save_text_status_0;
5696         if (ndr_flags & NDR_SCALARS) {
5697                 NDR_CHECK(ndr_pull_align(ndr, 5));
5698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5700                 if (_ptr_printer_name) {
5701                         NDR_PULL_ALLOC(ndr, r->printer_name);
5702                 } else {
5703                         r->printer_name = NULL;
5704                 }
5705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5706                 if (_ptr_server_name) {
5707                         NDR_PULL_ALLOC(ndr, r->server_name);
5708                 } else {
5709                         r->server_name = NULL;
5710                 }
5711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5712                 if (_ptr_user_name) {
5713                         NDR_PULL_ALLOC(ndr, r->user_name);
5714                 } else {
5715                         r->user_name = NULL;
5716                 }
5717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5718                 if (_ptr_document_name) {
5719                         NDR_PULL_ALLOC(ndr, r->document_name);
5720                 } else {
5721                         r->document_name = NULL;
5722                 }
5723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5724                 if (_ptr_notify_name) {
5725                         NDR_PULL_ALLOC(ndr, r->notify_name);
5726                 } else {
5727                         r->notify_name = NULL;
5728                 }
5729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5730                 if (_ptr_data_type) {
5731                         NDR_PULL_ALLOC(ndr, r->data_type);
5732                 } else {
5733                         r->data_type = NULL;
5734                 }
5735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5736                 if (_ptr_print_processor) {
5737                         NDR_PULL_ALLOC(ndr, r->print_processor);
5738                 } else {
5739                         r->print_processor = NULL;
5740                 }
5741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5742                 if (_ptr_parameters) {
5743                         NDR_PULL_ALLOC(ndr, r->parameters);
5744                 } else {
5745                         r->parameters = NULL;
5746                 }
5747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5748                 if (_ptr_driver_name) {
5749                         NDR_PULL_ALLOC(ndr, r->driver_name);
5750                 } else {
5751                         r->driver_name = NULL;
5752                 }
5753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5755                 if (_ptr_text_status) {
5756                         NDR_PULL_ALLOC(ndr, r->text_status);
5757                 } else {
5758                         r->text_status = NULL;
5759                 }
5760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5761                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5763                 if (r->priority > 99) {
5764                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5765                 }
5766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5771                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5775                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5776         }
5777         if (ndr_flags & NDR_BUFFERS) {
5778                 if (r->printer_name) {
5779                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5780                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5781                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5782                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5783                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5784                                 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));
5785                         }
5786                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5787                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5789                 }
5790                 if (r->server_name) {
5791                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5792                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5793                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5794                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5795                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5796                                 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));
5797                         }
5798                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5799                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5801                 }
5802                 if (r->user_name) {
5803                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5804                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5806                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5807                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5808                                 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));
5809                         }
5810                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5813                 }
5814                 if (r->document_name) {
5815                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5816                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5819                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5820                                 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));
5821                         }
5822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5823                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5825                 }
5826                 if (r->notify_name) {
5827                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5828                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5829                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5830                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5831                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5832                                 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));
5833                         }
5834                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5835                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5837                 }
5838                 if (r->data_type) {
5839                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5840                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5842                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5843                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5844                                 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));
5845                         }
5846                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5847                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5849                 }
5850                 if (r->print_processor) {
5851                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5852                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5853                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5854                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5855                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5856                                 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));
5857                         }
5858                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5859                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5861                 }
5862                 if (r->parameters) {
5863                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5864                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5866                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5867                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5868                                 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));
5869                         }
5870                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5871                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5873                 }
5874                 if (r->driver_name) {
5875                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5876                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5877                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5878                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5879                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5880                                 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));
5881                         }
5882                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5883                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5885                 }
5886                 if (r->text_status) {
5887                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5888                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5889                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5890                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5891                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5892                                 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));
5893                         }
5894                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5895                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5897                 }
5898         }
5899         return NDR_ERR_SUCCESS;
5900 }
5901
5902 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5903 {
5904         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5905         ndr->depth++;
5906         ndr_print_uint32(ndr, "job_id", r->job_id);
5907         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5908         ndr->depth++;
5909         if (r->printer_name) {
5910                 ndr_print_string(ndr, "printer_name", r->printer_name);
5911         }
5912         ndr->depth--;
5913         ndr_print_ptr(ndr, "server_name", r->server_name);
5914         ndr->depth++;
5915         if (r->server_name) {
5916                 ndr_print_string(ndr, "server_name", r->server_name);
5917         }
5918         ndr->depth--;
5919         ndr_print_ptr(ndr, "user_name", r->user_name);
5920         ndr->depth++;
5921         if (r->user_name) {
5922                 ndr_print_string(ndr, "user_name", r->user_name);
5923         }
5924         ndr->depth--;
5925         ndr_print_ptr(ndr, "document_name", r->document_name);
5926         ndr->depth++;
5927         if (r->document_name) {
5928                 ndr_print_string(ndr, "document_name", r->document_name);
5929         }
5930         ndr->depth--;
5931         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5932         ndr->depth++;
5933         if (r->notify_name) {
5934                 ndr_print_string(ndr, "notify_name", r->notify_name);
5935         }
5936         ndr->depth--;
5937         ndr_print_ptr(ndr, "data_type", r->data_type);
5938         ndr->depth++;
5939         if (r->data_type) {
5940                 ndr_print_string(ndr, "data_type", r->data_type);
5941         }
5942         ndr->depth--;
5943         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5944         ndr->depth++;
5945         if (r->print_processor) {
5946                 ndr_print_string(ndr, "print_processor", r->print_processor);
5947         }
5948         ndr->depth--;
5949         ndr_print_ptr(ndr, "parameters", r->parameters);
5950         ndr->depth++;
5951         if (r->parameters) {
5952                 ndr_print_string(ndr, "parameters", r->parameters);
5953         }
5954         ndr->depth--;
5955         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5956         ndr->depth++;
5957         if (r->driver_name) {
5958                 ndr_print_string(ndr, "driver_name", r->driver_name);
5959         }
5960         ndr->depth--;
5961         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5962         ndr_print_ptr(ndr, "text_status", r->text_status);
5963         ndr->depth++;
5964         if (r->text_status) {
5965                 ndr_print_string(ndr, "text_status", r->text_status);
5966         }
5967         ndr->depth--;
5968         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5969         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5970         ndr_print_uint32(ndr, "priority", r->priority);
5971         ndr_print_uint32(ndr, "position", r->position);
5972         ndr_print_uint32(ndr, "start_time", r->start_time);
5973         ndr_print_uint32(ndr, "until_time", r->until_time);
5974         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5975         ndr_print_uint32(ndr, "size", r->size);
5976         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5977         ndr_print_uint32(ndr, "time", r->time);
5978         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5979         ndr_print_uint32(ndr, "size_high", r->size_high);
5980         ndr->depth--;
5981 }
5982
5983 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5984 {
5985         if (ndr_flags & NDR_SCALARS) {
5986                 int level = ndr_push_get_switch_value(ndr, r);
5987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5988                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5989                 switch (level) {
5990                         case 1: {
5991                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5992                         break; }
5993
5994                         case 2: {
5995                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5996                         break; }
5997
5998                         case 3: {
5999                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6000                         break; }
6001
6002                         case 4: {
6003                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6004                         break; }
6005
6006                         default: {
6007                         break; }
6008
6009                 }
6010         }
6011         if (ndr_flags & NDR_BUFFERS) {
6012                 int level = ndr_push_get_switch_value(ndr, r);
6013                 switch (level) {
6014                         case 1:
6015                                 if (r->info1) {
6016                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6017                                 }
6018                         break;
6019
6020                         case 2:
6021                                 if (r->info2) {
6022                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6023                                 }
6024                         break;
6025
6026                         case 3:
6027                                 if (r->info3) {
6028                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6029                                 }
6030                         break;
6031
6032                         case 4:
6033                                 if (r->info4) {
6034                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6035                                 }
6036                         break;
6037
6038                         default:
6039                         break;
6040
6041                 }
6042         }
6043         return NDR_ERR_SUCCESS;
6044 }
6045
6046 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6047 {
6048         int level;
6049         uint32_t _level;
6050         TALLOC_CTX *_mem_save_info1_0;
6051         TALLOC_CTX *_mem_save_info2_0;
6052         TALLOC_CTX *_mem_save_info3_0;
6053         TALLOC_CTX *_mem_save_info4_0;
6054         level = ndr_pull_get_switch_value(ndr, r);
6055         if (ndr_flags & NDR_SCALARS) {
6056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6057                 if (_level != level) {
6058                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6059                 }
6060                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6061                 switch (level) {
6062                         case 1: {
6063                                 uint32_t _ptr_info1;
6064                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6065                                 if (_ptr_info1) {
6066                                         NDR_PULL_ALLOC(ndr, r->info1);
6067                                 } else {
6068                                         r->info1 = NULL;
6069                                 }
6070                         break; }
6071
6072                         case 2: {
6073                                 uint32_t _ptr_info2;
6074                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6075                                 if (_ptr_info2) {
6076                                         NDR_PULL_ALLOC(ndr, r->info2);
6077                                 } else {
6078                                         r->info2 = NULL;
6079                                 }
6080                         break; }
6081
6082                         case 3: {
6083                                 uint32_t _ptr_info3;
6084                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6085                                 if (_ptr_info3) {
6086                                         NDR_PULL_ALLOC(ndr, r->info3);
6087                                 } else {
6088                                         r->info3 = NULL;
6089                                 }
6090                         break; }
6091
6092                         case 4: {
6093                                 uint32_t _ptr_info4;
6094                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6095                                 if (_ptr_info4) {
6096                                         NDR_PULL_ALLOC(ndr, r->info4);
6097                                 } else {
6098                                         r->info4 = NULL;
6099                                 }
6100                         break; }
6101
6102                         default: {
6103                         break; }
6104
6105                 }
6106         }
6107         if (ndr_flags & NDR_BUFFERS) {
6108                 switch (level) {
6109                         case 1:
6110                                 if (r->info1) {
6111                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6112                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6113                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6114                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6115                                 }
6116                         break;
6117
6118                         case 2:
6119                                 if (r->info2) {
6120                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6121                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6122                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6123                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6124                                 }
6125                         break;
6126
6127                         case 3:
6128                                 if (r->info3) {
6129                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6130                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6131                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6132                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6133                                 }
6134                         break;
6135
6136                         case 4:
6137                                 if (r->info4) {
6138                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6139                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6140                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6141                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6142                                 }
6143                         break;
6144
6145                         default:
6146                         break;
6147
6148                 }
6149         }
6150         return NDR_ERR_SUCCESS;
6151 }
6152
6153 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6154 {
6155         int level;
6156         level = ndr_print_get_switch_value(ndr, r);
6157         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6158         switch (level) {
6159                 case 1:
6160                         ndr_print_ptr(ndr, "info1", r->info1);
6161                         ndr->depth++;
6162                         if (r->info1) {
6163                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6164                         }
6165                         ndr->depth--;
6166                 break;
6167
6168                 case 2:
6169                         ndr_print_ptr(ndr, "info2", r->info2);
6170                         ndr->depth++;
6171                         if (r->info2) {
6172                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6173                         }
6174                         ndr->depth--;
6175                 break;
6176
6177                 case 3:
6178                         ndr_print_ptr(ndr, "info3", r->info3);
6179                         ndr->depth++;
6180                         if (r->info3) {
6181                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6182                         }
6183                         ndr->depth--;
6184                 break;
6185
6186                 case 4:
6187                         ndr_print_ptr(ndr, "info4", r->info4);
6188                         ndr->depth++;
6189                         if (r->info4) {
6190                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6191                         }
6192                         ndr->depth--;
6193                 break;
6194
6195                 default:
6196                 break;
6197
6198         }
6199 }
6200
6201 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6202 {
6203         if (ndr_flags & NDR_SCALARS) {
6204                 NDR_CHECK(ndr_push_align(ndr, 5));
6205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6206                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6207                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6208                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6209         }
6210         if (ndr_flags & NDR_BUFFERS) {
6211                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6212         }
6213         return NDR_ERR_SUCCESS;
6214 }
6215
6216 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6217 {
6218         if (ndr_flags & NDR_SCALARS) {
6219                 NDR_CHECK(ndr_pull_align(ndr, 5));
6220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6221                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6222                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6223                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6224         }
6225         if (ndr_flags & NDR_BUFFERS) {
6226                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6227         }
6228         return NDR_ERR_SUCCESS;
6229 }
6230
6231 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6232 {
6233         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6234         ndr->depth++;
6235         ndr_print_uint32(ndr, "level", r->level);
6236         ndr_print_set_switch_value(ndr, &r->info, r->level);
6237         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6238         ndr->depth--;
6239 }
6240
6241 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6242 {
6243         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6244         return NDR_ERR_SUCCESS;
6245 }
6246
6247 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6248 {
6249         uint32_t v;
6250         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6251         *r = v;
6252         return NDR_ERR_SUCCESS;
6253 }
6254
6255 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6256 {
6257         const char *val = NULL;
6258
6259         switch (r) {
6260                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6261                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6262                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6263                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6264                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6265                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6266                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6267                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6268                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6269         }
6270         ndr_print_enum(ndr, name, "ENUM", val, r);
6271 }
6272
6273 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6274 {
6275         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6276         return NDR_ERR_SUCCESS;
6277 }
6278
6279 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6280 {
6281         uint32_t v;
6282         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6283         *r = v;
6284         return NDR_ERR_SUCCESS;
6285 }
6286
6287 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6288 {
6289         const char *val = NULL;
6290
6291         switch (r) {
6292                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6293                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6294                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6295                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6296                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6297         }
6298         ndr_print_enum(ndr, name, "ENUM", val, r);
6299 }
6300
6301 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6302 {
6303         if (ndr_flags & NDR_SCALARS) {
6304                 NDR_CHECK(ndr_push_align(ndr, 5));
6305                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6306                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6310                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6322                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6325                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6329                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6330                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6334                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6335         }
6336         if (ndr_flags & NDR_BUFFERS) {
6337                 if (r->servername) {
6338                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6339                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6340                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6342                 }
6343                 if (r->printername) {
6344                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6345                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6346                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6348                 }
6349         }
6350         return NDR_ERR_SUCCESS;
6351 }
6352
6353 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6354 {
6355         uint32_t _ptr_servername;
6356         TALLOC_CTX *_mem_save_servername_0;
6357         uint32_t _ptr_printername;
6358         TALLOC_CTX *_mem_save_printername_0;
6359         if (ndr_flags & NDR_SCALARS) {
6360                 NDR_CHECK(ndr_pull_align(ndr, 5));
6361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6362                 if (_ptr_servername) {
6363                         NDR_PULL_ALLOC(ndr, r->servername);
6364                 } else {
6365                         r->servername = NULL;
6366                 }
6367                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6368                 if (_ptr_printername) {
6369                         NDR_PULL_ALLOC(ndr, r->printername);
6370                 } else {
6371                         r->printername = NULL;
6372                 }
6373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6376                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6388                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6391                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6395                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6396                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6400                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6401         }
6402         if (ndr_flags & NDR_BUFFERS) {
6403                 if (r->servername) {
6404                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6405                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6406                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6407                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6408                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6409                                 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));
6410                         }
6411                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6412                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6414                 }
6415                 if (r->printername) {
6416                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6417                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6418                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6419                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6420                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6421                                 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));
6422                         }
6423                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6424                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6425                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6426                 }
6427         }
6428         return NDR_ERR_SUCCESS;
6429 }
6430
6431 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6432 {
6433         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6434         ndr->depth++;
6435         ndr_print_ptr(ndr, "servername", r->servername);
6436         ndr->depth++;
6437         if (r->servername) {
6438                 ndr_print_string(ndr, "servername", r->servername);
6439         }
6440         ndr->depth--;
6441         ndr_print_ptr(ndr, "printername", r->printername);
6442         ndr->depth++;
6443         if (r->printername) {
6444                 ndr_print_string(ndr, "printername", r->printername);
6445         }
6446         ndr->depth--;
6447         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6448         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6449         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6450         ndr_print_spoolss_Time(ndr, "time", &r->time);
6451         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6452         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6453         ndr_print_uint32(ndr, "version", r->version);
6454         ndr_print_uint32(ndr, "free_build", r->free_build);
6455         ndr_print_uint32(ndr, "spooling", r->spooling);
6456         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6457         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6458         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6459         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6460         ndr_print_uint32(ndr, "job_error", r->job_error);
6461         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6462         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6463         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6464         ndr_print_uint32(ndr, "change_id", r->change_id);
6465         ndr_print_WERROR(ndr, "last_error", r->last_error);
6466         ndr_print_uint32(ndr, "status", r->status);
6467         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6468         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6469         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6470         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6471         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6472         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6473         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6474         ndr->depth--;
6475 }
6476
6477 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6478 {
6479         if (ndr_flags & NDR_SCALARS) {
6480                 NDR_CHECK(ndr_push_align(ndr, 5));
6481                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6483                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6484                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6485                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6486         }
6487         if (ndr_flags & NDR_BUFFERS) {
6488                 if (r->description) {
6489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6490                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6491                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6492                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6493                 }
6494                 if (r->name) {
6495                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6496                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6497                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6498                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6499                 }
6500                 if (r->comment) {
6501                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6502                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6504                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6505                 }
6506         }
6507         return NDR_ERR_SUCCESS;
6508 }
6509
6510 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6511 {
6512         uint32_t _ptr_description;
6513         TALLOC_CTX *_mem_save_description_0;
6514         uint32_t _ptr_name;
6515         TALLOC_CTX *_mem_save_name_0;
6516         uint32_t _ptr_comment;
6517         TALLOC_CTX *_mem_save_comment_0;
6518         if (ndr_flags & NDR_SCALARS) {
6519                 NDR_CHECK(ndr_pull_align(ndr, 5));
6520                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6522                 if (_ptr_description) {
6523                         NDR_PULL_ALLOC(ndr, r->description);
6524                 } else {
6525                         r->description = NULL;
6526                 }
6527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6528                 if (_ptr_name) {
6529                         NDR_PULL_ALLOC(ndr, r->name);
6530                 } else {
6531                         r->name = NULL;
6532                 }
6533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6534                 if (_ptr_comment) {
6535                         NDR_PULL_ALLOC(ndr, r->comment);
6536                 } else {
6537                         r->comment = NULL;
6538                 }
6539                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6540         }
6541         if (ndr_flags & NDR_BUFFERS) {
6542                 if (r->description) {
6543                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6544                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6545                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6546                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6547                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6548                                 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));
6549                         }
6550                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6551                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6553                 }
6554                 if (r->name) {
6555                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6556                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6559                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6560                                 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));
6561                         }
6562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6565                 }
6566                 if (r->comment) {
6567                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6568                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6569                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6570                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6571                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6572                                 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));
6573                         }
6574                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6575                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6576                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6577                 }
6578         }
6579         return NDR_ERR_SUCCESS;
6580 }
6581
6582 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6583 {
6584         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6585         ndr->depth++;
6586         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6587         ndr_print_ptr(ndr, "description", r->description);
6588         ndr->depth++;
6589         if (r->description) {
6590                 ndr_print_string(ndr, "description", r->description);
6591         }
6592         ndr->depth--;
6593         ndr_print_ptr(ndr, "name", r->name);
6594         ndr->depth++;
6595         if (r->name) {
6596                 ndr_print_string(ndr, "name", r->name);
6597         }
6598         ndr->depth--;
6599         ndr_print_ptr(ndr, "comment", r->comment);
6600         ndr->depth++;
6601         if (r->comment) {
6602                 ndr_print_string(ndr, "comment", r->comment);
6603         }
6604         ndr->depth--;
6605         ndr->depth--;
6606 }
6607
6608 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6609 {
6610         if (ndr_flags & NDR_SCALARS) {
6611                 NDR_CHECK(ndr_push_align(ndr, 5));
6612                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6625                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6630                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6633                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6634         }
6635         if (ndr_flags & NDR_BUFFERS) {
6636                 if (r->servername) {
6637                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6638                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6639                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6640                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6641                 }
6642                 if (r->printername) {
6643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6644                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6646                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6647                 }
6648                 if (r->sharename) {
6649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6652                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6653                 }
6654                 if (r->portname) {
6655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6659                 }
6660                 if (r->drivername) {
6661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6665                 }
6666                 if (r->comment) {
6667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6669                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6670                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6671                 }
6672                 if (r->location) {
6673                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6674                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6675                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6677                 }
6678                 if (r->devmode) {
6679                         {
6680                                 struct ndr_push *_ndr_devmode;
6681                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6682                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6683                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6684                         }
6685                 }
6686                 if (r->sepfile) {
6687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6691                 }
6692                 if (r->printprocessor) {
6693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6696                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6697                 }
6698                 if (r->datatype) {
6699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6702                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6703                 }
6704                 if (r->parameters) {
6705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6708                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6709                 }
6710                 if (r->secdesc) {
6711                         {
6712                                 struct ndr_push *_ndr_secdesc;
6713                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6714                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6715                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6716                         }
6717                 }
6718         }
6719         return NDR_ERR_SUCCESS;
6720 }
6721
6722 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6723 {
6724         uint32_t _ptr_servername;
6725         TALLOC_CTX *_mem_save_servername_0;
6726         uint32_t _ptr_printername;
6727         TALLOC_CTX *_mem_save_printername_0;
6728         uint32_t _ptr_sharename;
6729         TALLOC_CTX *_mem_save_sharename_0;
6730         uint32_t _ptr_portname;
6731         TALLOC_CTX *_mem_save_portname_0;
6732         uint32_t _ptr_drivername;
6733         TALLOC_CTX *_mem_save_drivername_0;
6734         uint32_t _ptr_comment;
6735         TALLOC_CTX *_mem_save_comment_0;
6736         uint32_t _ptr_location;
6737         TALLOC_CTX *_mem_save_location_0;
6738         uint32_t _ptr_devmode;
6739         TALLOC_CTX *_mem_save_devmode_0;
6740         uint32_t _ptr_sepfile;
6741         TALLOC_CTX *_mem_save_sepfile_0;
6742         uint32_t _ptr_printprocessor;
6743         TALLOC_CTX *_mem_save_printprocessor_0;
6744         uint32_t _ptr_datatype;
6745         TALLOC_CTX *_mem_save_datatype_0;
6746         uint32_t _ptr_parameters;
6747         TALLOC_CTX *_mem_save_parameters_0;
6748         uint32_t _ptr_secdesc;
6749         TALLOC_CTX *_mem_save_secdesc_0;
6750         if (ndr_flags & NDR_SCALARS) {
6751                 NDR_CHECK(ndr_pull_align(ndr, 5));
6752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6753                 if (_ptr_servername) {
6754                         NDR_PULL_ALLOC(ndr, r->servername);
6755                 } else {
6756                         r->servername = NULL;
6757                 }
6758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6759                 if (_ptr_printername) {
6760                         NDR_PULL_ALLOC(ndr, r->printername);
6761                 } else {
6762                         r->printername = NULL;
6763                 }
6764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6765                 if (_ptr_sharename) {
6766                         NDR_PULL_ALLOC(ndr, r->sharename);
6767                 } else {
6768                         r->sharename = NULL;
6769                 }
6770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6771                 if (_ptr_portname) {
6772                         NDR_PULL_ALLOC(ndr, r->portname);
6773                 } else {
6774                         r->portname = NULL;
6775                 }
6776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6777                 if (_ptr_drivername) {
6778                         NDR_PULL_ALLOC(ndr, r->drivername);
6779                 } else {
6780                         r->drivername = NULL;
6781                 }
6782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6783                 if (_ptr_comment) {
6784                         NDR_PULL_ALLOC(ndr, r->comment);
6785                 } else {
6786                         r->comment = NULL;
6787                 }
6788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6789                 if (_ptr_location) {
6790                         NDR_PULL_ALLOC(ndr, r->location);
6791                 } else {
6792                         r->location = NULL;
6793                 }
6794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6795                 if (_ptr_devmode) {
6796                         NDR_PULL_ALLOC(ndr, r->devmode);
6797                 } else {
6798                         r->devmode = NULL;
6799                 }
6800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6801                 if (_ptr_sepfile) {
6802                         NDR_PULL_ALLOC(ndr, r->sepfile);
6803                 } else {
6804                         r->sepfile = NULL;
6805                 }
6806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6807                 if (_ptr_printprocessor) {
6808                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6809                 } else {
6810                         r->printprocessor = NULL;
6811                 }
6812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6813                 if (_ptr_datatype) {
6814                         NDR_PULL_ALLOC(ndr, r->datatype);
6815                 } else {
6816                         r->datatype = NULL;
6817                 }
6818                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6819                 if (_ptr_parameters) {
6820                         NDR_PULL_ALLOC(ndr, r->parameters);
6821                 } else {
6822                         r->parameters = NULL;
6823                 }
6824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6825                 if (_ptr_secdesc) {
6826                         NDR_PULL_ALLOC(ndr, r->secdesc);
6827                 } else {
6828                         r->secdesc = NULL;
6829                 }
6830                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6832                 if (r->priority > 99) {
6833                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6834                 }
6835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6838                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6841                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6842         }
6843         if (ndr_flags & NDR_BUFFERS) {
6844                 if (r->servername) {
6845                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6846                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6847                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6848                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6849                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6850                                 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));
6851                         }
6852                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6853                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6854                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6855                 }
6856                 if (r->printername) {
6857                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6858                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6859                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6860                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6861                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6862                                 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));
6863                         }
6864                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6865                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6867                 }
6868                 if (r->sharename) {
6869                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6870                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6871                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6872                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6873                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6874                                 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));
6875                         }
6876                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6877                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6879                 }
6880                 if (r->portname) {
6881                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6882                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6884                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6885                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6886                                 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));
6887                         }
6888                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6889                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6891                 }
6892                 if (r->drivername) {
6893                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6894                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6895                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6896                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6897                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6898                                 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));
6899                         }
6900                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6901                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6903                 }
6904                 if (r->comment) {
6905                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6906                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6908                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6909                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6910                                 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));
6911                         }
6912                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6913                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6915                 }
6916                 if (r->location) {
6917                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6918                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6920                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6921                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6922                                 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));
6923                         }
6924                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6925                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6927                 }
6928                 if (r->devmode) {
6929                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6930                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6931                         {
6932                                 struct ndr_pull *_ndr_devmode;
6933                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6934                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6935                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6936                         }
6937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6938                 }
6939                 if (r->sepfile) {
6940                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6941                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6942                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6943                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6944                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6945                                 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));
6946                         }
6947                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6948                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6950                 }
6951                 if (r->printprocessor) {
6952                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6953                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6956                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6957                                 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));
6958                         }
6959                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6960                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6962                 }
6963                 if (r->datatype) {
6964                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6965                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6966                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6967                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6968                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6969                                 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));
6970                         }
6971                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6972                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6974                 }
6975                 if (r->parameters) {
6976                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6977                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6978                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6979                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6980                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6981                                 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));
6982                         }
6983                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6984                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6985                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6986                 }
6987                 if (r->secdesc) {
6988                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6989                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6990                         {
6991                                 struct ndr_pull *_ndr_secdesc;
6992                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6993                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6994                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6995                         }
6996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6997                 }
6998         }
6999         return NDR_ERR_SUCCESS;
7000 }
7001
7002 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7003 {
7004         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7005         ndr->depth++;
7006         ndr_print_ptr(ndr, "servername", r->servername);
7007         ndr->depth++;
7008         if (r->servername) {
7009                 ndr_print_string(ndr, "servername", r->servername);
7010         }
7011         ndr->depth--;
7012         ndr_print_ptr(ndr, "printername", r->printername);
7013         ndr->depth++;
7014         if (r->printername) {
7015                 ndr_print_string(ndr, "printername", r->printername);
7016         }
7017         ndr->depth--;
7018         ndr_print_ptr(ndr, "sharename", r->sharename);
7019         ndr->depth++;
7020         if (r->sharename) {
7021                 ndr_print_string(ndr, "sharename", r->sharename);
7022         }
7023         ndr->depth--;
7024         ndr_print_ptr(ndr, "portname", r->portname);
7025         ndr->depth++;
7026         if (r->portname) {
7027                 ndr_print_string(ndr, "portname", r->portname);
7028         }
7029         ndr->depth--;
7030         ndr_print_ptr(ndr, "drivername", r->drivername);
7031         ndr->depth++;
7032         if (r->drivername) {
7033                 ndr_print_string(ndr, "drivername", r->drivername);
7034         }
7035         ndr->depth--;
7036         ndr_print_ptr(ndr, "comment", r->comment);
7037         ndr->depth++;
7038         if (r->comment) {
7039                 ndr_print_string(ndr, "comment", r->comment);
7040         }
7041         ndr->depth--;
7042         ndr_print_ptr(ndr, "location", r->location);
7043         ndr->depth++;
7044         if (r->location) {
7045                 ndr_print_string(ndr, "location", r->location);
7046         }
7047         ndr->depth--;
7048         ndr_print_ptr(ndr, "devmode", r->devmode);
7049         ndr->depth++;
7050         if (r->devmode) {
7051                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
7052         }
7053         ndr->depth--;
7054         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7055         ndr->depth++;
7056         if (r->sepfile) {
7057                 ndr_print_string(ndr, "sepfile", r->sepfile);
7058         }
7059         ndr->depth--;
7060         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7061         ndr->depth++;
7062         if (r->printprocessor) {
7063                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7064         }
7065         ndr->depth--;
7066         ndr_print_ptr(ndr, "datatype", r->datatype);
7067         ndr->depth++;
7068         if (r->datatype) {
7069                 ndr_print_string(ndr, "datatype", r->datatype);
7070         }
7071         ndr->depth--;
7072         ndr_print_ptr(ndr, "parameters", r->parameters);
7073         ndr->depth++;
7074         if (r->parameters) {
7075                 ndr_print_string(ndr, "parameters", r->parameters);
7076         }
7077         ndr->depth--;
7078         ndr_print_ptr(ndr, "secdesc", r->secdesc);
7079         ndr->depth++;
7080         if (r->secdesc) {
7081                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
7082         }
7083         ndr->depth--;
7084         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7085         ndr_print_uint32(ndr, "priority", r->priority);
7086         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7087         ndr_print_uint32(ndr, "starttime", r->starttime);
7088         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7089         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7090         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7091         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7092         ndr->depth--;
7093 }
7094
7095 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7096 {
7097         if (ndr_flags & NDR_SCALARS) {
7098                 NDR_CHECK(ndr_push_align(ndr, 4));
7099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7100                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7101         }
7102         if (ndr_flags & NDR_BUFFERS) {
7103         }
7104         return NDR_ERR_SUCCESS;
7105 }
7106
7107 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7108 {
7109         if (ndr_flags & NDR_SCALARS) {
7110                 NDR_CHECK(ndr_pull_align(ndr, 4));
7111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7112                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7113         }
7114         if (ndr_flags & NDR_BUFFERS) {
7115         }
7116         return NDR_ERR_SUCCESS;
7117 }
7118
7119 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7120 {
7121         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7122         ndr->depth++;
7123         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7124         ndr->depth--;
7125 }
7126
7127 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7128 {
7129         if (ndr_flags & NDR_SCALARS) {
7130                 NDR_CHECK(ndr_push_align(ndr, 5));
7131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7133                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7134                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7135         }
7136         if (ndr_flags & NDR_BUFFERS) {
7137                 if (r->printername) {
7138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7142                 }
7143                 if (r->servername) {
7144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7147                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7148                 }
7149         }
7150         return NDR_ERR_SUCCESS;
7151 }
7152
7153 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7154 {
7155         uint32_t _ptr_printername;
7156         TALLOC_CTX *_mem_save_printername_0;
7157         uint32_t _ptr_servername;
7158         TALLOC_CTX *_mem_save_servername_0;
7159         if (ndr_flags & NDR_SCALARS) {
7160                 NDR_CHECK(ndr_pull_align(ndr, 5));
7161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7162                 if (_ptr_printername) {
7163                         NDR_PULL_ALLOC(ndr, r->printername);
7164                 } else {
7165                         r->printername = NULL;
7166                 }
7167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7168                 if (_ptr_servername) {
7169                         NDR_PULL_ALLOC(ndr, r->servername);
7170                 } else {
7171                         r->servername = NULL;
7172                 }
7173                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7174                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7175         }
7176         if (ndr_flags & NDR_BUFFERS) {
7177                 if (r->printername) {
7178                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7179                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7182                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7183                                 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));
7184                         }
7185                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7186                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7188                 }
7189                 if (r->servername) {
7190                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7191                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7192                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7193                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7194                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7195                                 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));
7196                         }
7197                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7198                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7200                 }
7201         }
7202         return NDR_ERR_SUCCESS;
7203 }
7204
7205 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7206 {
7207         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7208         ndr->depth++;
7209         ndr_print_ptr(ndr, "printername", r->printername);
7210         ndr->depth++;
7211         if (r->printername) {
7212                 ndr_print_string(ndr, "printername", r->printername);
7213         }
7214         ndr->depth--;
7215         ndr_print_ptr(ndr, "servername", r->servername);
7216         ndr->depth++;
7217         if (r->servername) {
7218                 ndr_print_string(ndr, "servername", r->servername);
7219         }
7220         ndr->depth--;
7221         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7222         ndr->depth--;
7223 }
7224
7225 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7226 {
7227         if (ndr_flags & NDR_SCALARS) {
7228                 NDR_CHECK(ndr_push_align(ndr, 5));
7229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7231                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7234                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7235         }
7236         if (ndr_flags & NDR_BUFFERS) {
7237                 if (r->printername) {
7238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7241                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7242                 }
7243                 if (r->portname) {
7244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7246                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7247                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7248                 }
7249         }
7250         return NDR_ERR_SUCCESS;
7251 }
7252
7253 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7254 {
7255         uint32_t _ptr_printername;
7256         TALLOC_CTX *_mem_save_printername_0;
7257         uint32_t _ptr_portname;
7258         TALLOC_CTX *_mem_save_portname_0;
7259         if (ndr_flags & NDR_SCALARS) {
7260                 NDR_CHECK(ndr_pull_align(ndr, 5));
7261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7262                 if (_ptr_printername) {
7263                         NDR_PULL_ALLOC(ndr, r->printername);
7264                 } else {
7265                         r->printername = NULL;
7266                 }
7267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7268                 if (_ptr_portname) {
7269                         NDR_PULL_ALLOC(ndr, r->portname);
7270                 } else {
7271                         r->portname = NULL;
7272                 }
7273                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7276                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7277         }
7278         if (ndr_flags & NDR_BUFFERS) {
7279                 if (r->printername) {
7280                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7281                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7282                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7283                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7284                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7285                                 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));
7286                         }
7287                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7288                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7290                 }
7291                 if (r->portname) {
7292                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7293                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7294                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7295                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7296                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7297                                 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));
7298                         }
7299                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7300                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7302                 }
7303         }
7304         return NDR_ERR_SUCCESS;
7305 }
7306
7307 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7308 {
7309         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7310         ndr->depth++;
7311         ndr_print_ptr(ndr, "printername", r->printername);
7312         ndr->depth++;
7313         if (r->printername) {
7314                 ndr_print_string(ndr, "printername", r->printername);
7315         }
7316         ndr->depth--;
7317         ndr_print_ptr(ndr, "portname", r->portname);
7318         ndr->depth++;
7319         if (r->portname) {
7320                 ndr_print_string(ndr, "portname", r->portname);
7321         }
7322         ndr->depth--;
7323         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7324         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7325         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7326         ndr->depth--;
7327 }
7328
7329 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7330 {
7331         if (ndr_flags & NDR_SCALARS) {
7332                 NDR_CHECK(ndr_push_align(ndr, 4));
7333                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7334                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7335         }
7336         if (ndr_flags & NDR_BUFFERS) {
7337         }
7338         return NDR_ERR_SUCCESS;
7339 }
7340
7341 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7342 {
7343         if (ndr_flags & NDR_SCALARS) {
7344                 NDR_CHECK(ndr_pull_align(ndr, 4));
7345                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7346                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7347         }
7348         if (ndr_flags & NDR_BUFFERS) {
7349         }
7350         return NDR_ERR_SUCCESS;
7351 }
7352
7353 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7354 {
7355         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7356         ndr->depth++;
7357         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7358         ndr->depth--;
7359 }
7360
7361 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7362 {
7363         if (ndr_flags & NDR_SCALARS) {
7364                 NDR_CHECK(ndr_push_align(ndr, 5));
7365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7366                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7367                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7368         }
7369         if (ndr_flags & NDR_BUFFERS) {
7370                 if (r->guid) {
7371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7374                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7375                 }
7376         }
7377         return NDR_ERR_SUCCESS;
7378 }
7379
7380 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7381 {
7382         uint32_t _ptr_guid;
7383         TALLOC_CTX *_mem_save_guid_0;
7384         if (ndr_flags & NDR_SCALARS) {
7385                 NDR_CHECK(ndr_pull_align(ndr, 5));
7386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7387                 if (_ptr_guid) {
7388                         NDR_PULL_ALLOC(ndr, r->guid);
7389                 } else {
7390                         r->guid = NULL;
7391                 }
7392                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7393                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7394         }
7395         if (ndr_flags & NDR_BUFFERS) {
7396                 if (r->guid) {
7397                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7398                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7399                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7400                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7401                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7402                                 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));
7403                         }
7404                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7405                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7406                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7407                 }
7408         }
7409         return NDR_ERR_SUCCESS;
7410 }
7411
7412 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7413 {
7414         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7415         ndr->depth++;
7416         ndr_print_ptr(ndr, "guid", r->guid);
7417         ndr->depth++;
7418         if (r->guid) {
7419                 ndr_print_string(ndr, "guid", r->guid);
7420         }
7421         ndr->depth--;
7422         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7423         ndr->depth--;
7424 }
7425
7426 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7427 {
7428         if (ndr_flags & NDR_SCALARS) {
7429                 int level = ndr_push_get_switch_value(ndr, r);
7430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7431                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7432                 switch (level) {
7433                         case 0: {
7434                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7435                         break; }
7436
7437                         case 1: {
7438                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7439                         break; }
7440
7441                         case 2: {
7442                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7443                         break; }
7444
7445                         case 3: {
7446                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7447                         break; }
7448
7449                         case 4: {
7450                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7451                         break; }
7452
7453                         case 5: {
7454                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7455                         break; }
7456
7457                         case 6: {
7458                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7459                         break; }
7460
7461                         case 7: {
7462                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7463                         break; }
7464
7465                         case 8: {
7466                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7467                         break; }
7468
7469                         case 9: {
7470                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7471                         break; }
7472
7473                         default: {
7474                         break; }
7475
7476                 }
7477         }
7478         if (ndr_flags & NDR_BUFFERS) {
7479                 int level = ndr_push_get_switch_value(ndr, r);
7480                 switch (level) {
7481                         case 0:
7482                                 if (r->info0) {
7483                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7484                                 }
7485                         break;
7486
7487                         case 1:
7488                                 if (r->info1) {
7489                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7490                                 }
7491                         break;
7492
7493                         case 2:
7494                                 if (r->info2) {
7495                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7496                                 }
7497                         break;
7498
7499                         case 3:
7500                                 if (r->info3) {
7501                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7502                                 }
7503                         break;
7504
7505                         case 4:
7506                                 if (r->info4) {
7507                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7508                                 }
7509                         break;
7510
7511                         case 5:
7512                                 if (r->info5) {
7513                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7514                                 }
7515                         break;
7516
7517                         case 6:
7518                                 if (r->info6) {
7519                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7520                                 }
7521                         break;
7522
7523                         case 7:
7524                                 if (r->info7) {
7525                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7526                                 }
7527                         break;
7528
7529                         case 8:
7530                                 if (r->info8) {
7531                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7532                                 }
7533                         break;
7534
7535                         case 9:
7536                                 if (r->info9) {
7537                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7538                                 }
7539                         break;
7540
7541                         default:
7542                         break;
7543
7544                 }
7545         }
7546         return NDR_ERR_SUCCESS;
7547 }
7548
7549 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7550 {
7551         int level;
7552         uint32_t _level;
7553         TALLOC_CTX *_mem_save_info0_0;
7554         TALLOC_CTX *_mem_save_info1_0;
7555         TALLOC_CTX *_mem_save_info2_0;
7556         TALLOC_CTX *_mem_save_info3_0;
7557         TALLOC_CTX *_mem_save_info4_0;
7558         TALLOC_CTX *_mem_save_info5_0;
7559         TALLOC_CTX *_mem_save_info6_0;
7560         TALLOC_CTX *_mem_save_info7_0;
7561         TALLOC_CTX *_mem_save_info8_0;
7562         TALLOC_CTX *_mem_save_info9_0;
7563         level = ndr_pull_get_switch_value(ndr, r);
7564         if (ndr_flags & NDR_SCALARS) {
7565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7566                 if (_level != level) {
7567                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7568                 }
7569                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7570                 switch (level) {
7571                         case 0: {
7572                                 uint32_t _ptr_info0;
7573                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7574                                 if (_ptr_info0) {
7575                                         NDR_PULL_ALLOC(ndr, r->info0);
7576                                 } else {
7577                                         r->info0 = NULL;
7578                                 }
7579                         break; }
7580
7581                         case 1: {
7582                                 uint32_t _ptr_info1;
7583                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7584                                 if (_ptr_info1) {
7585                                         NDR_PULL_ALLOC(ndr, r->info1);
7586                                 } else {
7587                                         r->info1 = NULL;
7588                                 }
7589                         break; }
7590
7591                         case 2: {
7592                                 uint32_t _ptr_info2;
7593                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7594                                 if (_ptr_info2) {
7595                                         NDR_PULL_ALLOC(ndr, r->info2);
7596                                 } else {
7597                                         r->info2 = NULL;
7598                                 }
7599                         break; }
7600
7601                         case 3: {
7602                                 uint32_t _ptr_info3;
7603                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7604                                 if (_ptr_info3) {
7605                                         NDR_PULL_ALLOC(ndr, r->info3);
7606                                 } else {
7607                                         r->info3 = NULL;
7608                                 }
7609                         break; }
7610
7611                         case 4: {
7612                                 uint32_t _ptr_info4;
7613                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7614                                 if (_ptr_info4) {
7615                                         NDR_PULL_ALLOC(ndr, r->info4);
7616                                 } else {
7617                                         r->info4 = NULL;
7618                                 }
7619                         break; }
7620
7621                         case 5: {
7622                                 uint32_t _ptr_info5;
7623                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7624                                 if (_ptr_info5) {
7625                                         NDR_PULL_ALLOC(ndr, r->info5);
7626                                 } else {
7627                                         r->info5 = NULL;
7628                                 }
7629                         break; }
7630
7631                         case 6: {
7632                                 uint32_t _ptr_info6;
7633                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7634                                 if (_ptr_info6) {
7635                                         NDR_PULL_ALLOC(ndr, r->info6);
7636                                 } else {
7637                                         r->info6 = NULL;
7638                                 }
7639                         break; }
7640
7641                         case 7: {
7642                                 uint32_t _ptr_info7;
7643                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7644                                 if (_ptr_info7) {
7645                                         NDR_PULL_ALLOC(ndr, r->info7);
7646                                 } else {
7647                                         r->info7 = NULL;
7648                                 }
7649                         break; }
7650
7651                         case 8: {
7652                                 uint32_t _ptr_info8;
7653                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7654                                 if (_ptr_info8) {
7655                                         NDR_PULL_ALLOC(ndr, r->info8);
7656                                 } else {
7657                                         r->info8 = NULL;
7658                                 }
7659                         break; }
7660
7661                         case 9: {
7662                                 uint32_t _ptr_info9;
7663                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7664                                 if (_ptr_info9) {
7665                                         NDR_PULL_ALLOC(ndr, r->info9);
7666                                 } else {
7667                                         r->info9 = NULL;
7668                                 }
7669                         break; }
7670
7671                         default: {
7672                         break; }
7673
7674                 }
7675         }
7676         if (ndr_flags & NDR_BUFFERS) {
7677                 switch (level) {
7678                         case 0:
7679                                 if (r->info0) {
7680                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7681                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7682                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7683                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7684                                 }
7685                         break;
7686
7687                         case 1:
7688                                 if (r->info1) {
7689                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7690                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7691                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7692                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7693                                 }
7694                         break;
7695
7696                         case 2:
7697                                 if (r->info2) {
7698                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7699                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7700                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7701                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7702                                 }
7703                         break;
7704
7705                         case 3:
7706                                 if (r->info3) {
7707                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7708                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7709                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7710                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7711                                 }
7712                         break;
7713
7714                         case 4:
7715                                 if (r->info4) {
7716                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7717                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7718                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7719                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7720                                 }
7721                         break;
7722
7723                         case 5:
7724                                 if (r->info5) {
7725                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7726                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7727                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7728                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7729                                 }
7730                         break;
7731
7732                         case 6:
7733                                 if (r->info6) {
7734                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7735                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7736                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7737                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7738                                 }
7739                         break;
7740
7741                         case 7:
7742                                 if (r->info7) {
7743                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7744                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7745                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7746                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7747                                 }
7748                         break;
7749
7750                         case 8:
7751                                 if (r->info8) {
7752                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7753                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7754                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7755                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7756                                 }
7757                         break;
7758
7759                         case 9:
7760                                 if (r->info9) {
7761                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7762                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7763                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7764                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7765                                 }
7766                         break;
7767
7768                         default:
7769                         break;
7770
7771                 }
7772         }
7773         return NDR_ERR_SUCCESS;
7774 }
7775
7776 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7777 {
7778         int level;
7779         level = ndr_print_get_switch_value(ndr, r);
7780         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7781         switch (level) {
7782                 case 0:
7783                         ndr_print_ptr(ndr, "info0", r->info0);
7784                         ndr->depth++;
7785                         if (r->info0) {
7786                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7787                         }
7788                         ndr->depth--;
7789                 break;
7790
7791                 case 1:
7792                         ndr_print_ptr(ndr, "info1", r->info1);
7793                         ndr->depth++;
7794                         if (r->info1) {
7795                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7796                         }
7797                         ndr->depth--;
7798                 break;
7799
7800                 case 2:
7801                         ndr_print_ptr(ndr, "info2", r->info2);
7802                         ndr->depth++;
7803                         if (r->info2) {
7804                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7805                         }
7806                         ndr->depth--;
7807                 break;
7808
7809                 case 3:
7810                         ndr_print_ptr(ndr, "info3", r->info3);
7811                         ndr->depth++;
7812                         if (r->info3) {
7813                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7814                         }
7815                         ndr->depth--;
7816                 break;
7817
7818                 case 4:
7819                         ndr_print_ptr(ndr, "info4", r->info4);
7820                         ndr->depth++;
7821                         if (r->info4) {
7822                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7823                         }
7824                         ndr->depth--;
7825                 break;
7826
7827                 case 5:
7828                         ndr_print_ptr(ndr, "info5", r->info5);
7829                         ndr->depth++;
7830                         if (r->info5) {
7831                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7832                         }
7833                         ndr->depth--;
7834                 break;
7835
7836                 case 6:
7837                         ndr_print_ptr(ndr, "info6", r->info6);
7838                         ndr->depth++;
7839                         if (r->info6) {
7840                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7841                         }
7842                         ndr->depth--;
7843                 break;
7844
7845                 case 7:
7846                         ndr_print_ptr(ndr, "info7", r->info7);
7847                         ndr->depth++;
7848                         if (r->info7) {
7849                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7850                         }
7851                         ndr->depth--;
7852                 break;
7853
7854                 case 8:
7855                         ndr_print_ptr(ndr, "info8", r->info8);
7856                         ndr->depth++;
7857                         if (r->info8) {
7858                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7859                         }
7860                         ndr->depth--;
7861                 break;
7862
7863                 case 9:
7864                         ndr_print_ptr(ndr, "info9", r->info9);
7865                         ndr->depth++;
7866                         if (r->info9) {
7867                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7868                         }
7869                         ndr->depth--;
7870                 break;
7871
7872                 default:
7873                 break;
7874
7875         }
7876 }
7877
7878 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7879 {
7880         if (ndr_flags & NDR_SCALARS) {
7881                 NDR_CHECK(ndr_push_align(ndr, 5));
7882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7883                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7884                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7885                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7886         }
7887         if (ndr_flags & NDR_BUFFERS) {
7888                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7889         }
7890         return NDR_ERR_SUCCESS;
7891 }
7892
7893 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7894 {
7895         if (ndr_flags & NDR_SCALARS) {
7896                 NDR_CHECK(ndr_pull_align(ndr, 5));
7897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7898                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7899                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7900                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7901         }
7902         if (ndr_flags & NDR_BUFFERS) {
7903                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7904         }
7905         return NDR_ERR_SUCCESS;
7906 }
7907
7908 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7909 {
7910         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7911         ndr->depth++;
7912         ndr_print_uint32(ndr, "level", r->level);
7913         ndr_print_set_switch_value(ndr, &r->info, r->level);
7914         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7915         ndr->depth--;
7916 }
7917
7918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7919 {
7920         if (ndr_flags & NDR_SCALARS) {
7921                 NDR_CHECK(ndr_push_align(ndr, 4));
7922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7923                 {
7924                         uint32_t _flags_save_string_array = ndr->flags;
7925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7926                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7927                         ndr->flags = _flags_save_string_array;
7928                 }
7929                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7930         }
7931         if (ndr_flags & NDR_BUFFERS) {
7932         }
7933         return NDR_ERR_SUCCESS;
7934 }
7935
7936 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7937 {
7938         if (ndr_flags & NDR_SCALARS) {
7939                 NDR_CHECK(ndr_pull_align(ndr, 4));
7940                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7941                 {
7942                         uint32_t _flags_save_string_array = ndr->flags;
7943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7944                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7945                         ndr->flags = _flags_save_string_array;
7946                 }
7947                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7948         }
7949         if (ndr_flags & NDR_BUFFERS) {
7950         }
7951         return NDR_ERR_SUCCESS;
7952 }
7953
7954 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7955 {
7956         ndr_print_struct(ndr, name, "spoolss_StringArray");
7957         ndr->depth++;
7958         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);
7959         ndr_print_string_array(ndr, "string", r->string);
7960         ndr->depth--;
7961 }
7962
7963 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7964 {
7965         if (ndr_flags & NDR_SCALARS) {
7966                 NDR_CHECK(ndr_push_align(ndr, 5));
7967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7968                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7969         }
7970         if (ndr_flags & NDR_BUFFERS) {
7971                 if (r->driver_name) {
7972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7976                 }
7977         }
7978         return NDR_ERR_SUCCESS;
7979 }
7980
7981 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7982 {
7983         uint32_t _ptr_driver_name;
7984         TALLOC_CTX *_mem_save_driver_name_0;
7985         if (ndr_flags & NDR_SCALARS) {
7986                 NDR_CHECK(ndr_pull_align(ndr, 5));
7987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7988                 if (_ptr_driver_name) {
7989                         NDR_PULL_ALLOC(ndr, r->driver_name);
7990                 } else {
7991                         r->driver_name = NULL;
7992                 }
7993                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7994         }
7995         if (ndr_flags & NDR_BUFFERS) {
7996                 if (r->driver_name) {
7997                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7998                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7999                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8000                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8001                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8002                                 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));
8003                         }
8004                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8005                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8006                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8007                 }
8008         }
8009         return NDR_ERR_SUCCESS;
8010 }
8011
8012 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8013 {
8014         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8015         ndr->depth++;
8016         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8017         ndr->depth++;
8018         if (r->driver_name) {
8019                 ndr_print_string(ndr, "driver_name", r->driver_name);
8020         }
8021         ndr->depth--;
8022         ndr->depth--;
8023 }
8024
8025 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8026 {
8027         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8028         return NDR_ERR_SUCCESS;
8029 }
8030
8031 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8032 {
8033         uint32_t v;
8034         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8035         *r = v;
8036         return NDR_ERR_SUCCESS;
8037 }
8038
8039 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8040 {
8041         const char *val = NULL;
8042
8043         switch (r) {
8044                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8045                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8046                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8047                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8048         }
8049         ndr_print_enum(ndr, name, "ENUM", val, r);
8050 }
8051
8052 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8053 {
8054         if (ndr_flags & NDR_SCALARS) {
8055                 NDR_CHECK(ndr_push_align(ndr, 5));
8056                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8062                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8063         }
8064         if (ndr_flags & NDR_BUFFERS) {
8065                 if (r->driver_name) {
8066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8068                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8069                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8070                 }
8071                 if (r->architecture) {
8072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8075                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8076                 }
8077                 if (r->driver_path) {
8078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8079                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8080                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8081                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8082                 }
8083                 if (r->data_file) {
8084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8085                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8087                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8088                 }
8089                 if (r->config_file) {
8090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8093                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8094                 }
8095         }
8096         return NDR_ERR_SUCCESS;
8097 }
8098
8099 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8100 {
8101         uint32_t _ptr_driver_name;
8102         TALLOC_CTX *_mem_save_driver_name_0;
8103         uint32_t _ptr_architecture;
8104         TALLOC_CTX *_mem_save_architecture_0;
8105         uint32_t _ptr_driver_path;
8106         TALLOC_CTX *_mem_save_driver_path_0;
8107         uint32_t _ptr_data_file;
8108         TALLOC_CTX *_mem_save_data_file_0;
8109         uint32_t _ptr_config_file;
8110         TALLOC_CTX *_mem_save_config_file_0;
8111         if (ndr_flags & NDR_SCALARS) {
8112                 NDR_CHECK(ndr_pull_align(ndr, 5));
8113                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8114                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8115                 if (_ptr_driver_name) {
8116                         NDR_PULL_ALLOC(ndr, r->driver_name);
8117                 } else {
8118                         r->driver_name = NULL;
8119                 }
8120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8121                 if (_ptr_architecture) {
8122                         NDR_PULL_ALLOC(ndr, r->architecture);
8123                 } else {
8124                         r->architecture = NULL;
8125                 }
8126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8127                 if (_ptr_driver_path) {
8128                         NDR_PULL_ALLOC(ndr, r->driver_path);
8129                 } else {
8130                         r->driver_path = NULL;
8131                 }
8132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8133                 if (_ptr_data_file) {
8134                         NDR_PULL_ALLOC(ndr, r->data_file);
8135                 } else {
8136                         r->data_file = NULL;
8137                 }
8138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8139                 if (_ptr_config_file) {
8140                         NDR_PULL_ALLOC(ndr, r->config_file);
8141                 } else {
8142                         r->config_file = NULL;
8143                 }
8144                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8145         }
8146         if (ndr_flags & NDR_BUFFERS) {
8147                 if (r->driver_name) {
8148                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8149                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8150                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8151                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8152                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8153                                 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));
8154                         }
8155                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8156                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8158                 }
8159                 if (r->architecture) {
8160                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8161                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8164                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8165                                 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));
8166                         }
8167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8168                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8170                 }
8171                 if (r->driver_path) {
8172                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8173                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8176                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8177                                 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));
8178                         }
8179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8182                 }
8183                 if (r->data_file) {
8184                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8185                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8186                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8187                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8188                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8189                                 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));
8190                         }
8191                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8192                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8194                 }
8195                 if (r->config_file) {
8196                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8197                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8198                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8199                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8200                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8201                                 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));
8202                         }
8203                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8204                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8206                 }
8207         }
8208         return NDR_ERR_SUCCESS;
8209 }
8210
8211 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8212 {
8213         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8214         ndr->depth++;
8215         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8216         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8217         ndr->depth++;
8218         if (r->driver_name) {
8219                 ndr_print_string(ndr, "driver_name", r->driver_name);
8220         }
8221         ndr->depth--;
8222         ndr_print_ptr(ndr, "architecture", r->architecture);
8223         ndr->depth++;
8224         if (r->architecture) {
8225                 ndr_print_string(ndr, "architecture", r->architecture);
8226         }
8227         ndr->depth--;
8228         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8229         ndr->depth++;
8230         if (r->driver_path) {
8231                 ndr_print_string(ndr, "driver_path", r->driver_path);
8232         }
8233         ndr->depth--;
8234         ndr_print_ptr(ndr, "data_file", r->data_file);
8235         ndr->depth++;
8236         if (r->data_file) {
8237                 ndr_print_string(ndr, "data_file", r->data_file);
8238         }
8239         ndr->depth--;
8240         ndr_print_ptr(ndr, "config_file", r->config_file);
8241         ndr->depth++;
8242         if (r->config_file) {
8243                 ndr_print_string(ndr, "config_file", r->config_file);
8244         }
8245         ndr->depth--;
8246         ndr->depth--;
8247 }
8248
8249 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8250 {
8251         if (ndr_flags & NDR_SCALARS) {
8252                 NDR_CHECK(ndr_push_align(ndr, 5));
8253                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8257                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8258                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8263                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8264                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8265         }
8266         if (ndr_flags & NDR_BUFFERS) {
8267                 if (r->driver_name) {
8268                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8270                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8271                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8272                 }
8273                 if (r->architecture) {
8274                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8275                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8276                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8277                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8278                 }
8279                 if (r->driver_path) {
8280                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8281                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8282                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8283                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8284                 }
8285                 if (r->data_file) {
8286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8288                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8289                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8290                 }
8291                 if (r->config_file) {
8292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8294                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8295                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8296                 }
8297                 if (r->help_file) {
8298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8301                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8302                 }
8303                 if (r->monitor_name) {
8304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8306                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8307                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8308                 }
8309                 if (r->default_datatype) {
8310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8313                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8314                 }
8315                 if (r->dependent_files) {
8316                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8317                 }
8318         }
8319         return NDR_ERR_SUCCESS;
8320 }
8321
8322 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8323 {
8324         uint32_t _ptr_driver_name;
8325         TALLOC_CTX *_mem_save_driver_name_0;
8326         uint32_t _ptr_architecture;
8327         TALLOC_CTX *_mem_save_architecture_0;
8328         uint32_t _ptr_driver_path;
8329         TALLOC_CTX *_mem_save_driver_path_0;
8330         uint32_t _ptr_data_file;
8331         TALLOC_CTX *_mem_save_data_file_0;
8332         uint32_t _ptr_config_file;
8333         TALLOC_CTX *_mem_save_config_file_0;
8334         uint32_t _ptr_help_file;
8335         TALLOC_CTX *_mem_save_help_file_0;
8336         uint32_t _ptr_monitor_name;
8337         TALLOC_CTX *_mem_save_monitor_name_0;
8338         uint32_t _ptr_default_datatype;
8339         TALLOC_CTX *_mem_save_default_datatype_0;
8340         uint32_t _ptr_dependent_files;
8341         TALLOC_CTX *_mem_save_dependent_files_0;
8342         if (ndr_flags & NDR_SCALARS) {
8343                 NDR_CHECK(ndr_pull_align(ndr, 5));
8344                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8346                 if (_ptr_driver_name) {
8347                         NDR_PULL_ALLOC(ndr, r->driver_name);
8348                 } else {
8349                         r->driver_name = NULL;
8350                 }
8351                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8352                 if (_ptr_architecture) {
8353                         NDR_PULL_ALLOC(ndr, r->architecture);
8354                 } else {
8355                         r->architecture = NULL;
8356                 }
8357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8358                 if (_ptr_driver_path) {
8359                         NDR_PULL_ALLOC(ndr, r->driver_path);
8360                 } else {
8361                         r->driver_path = NULL;
8362                 }
8363                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8364                 if (_ptr_data_file) {
8365                         NDR_PULL_ALLOC(ndr, r->data_file);
8366                 } else {
8367                         r->data_file = NULL;
8368                 }
8369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8370                 if (_ptr_config_file) {
8371                         NDR_PULL_ALLOC(ndr, r->config_file);
8372                 } else {
8373                         r->config_file = NULL;
8374                 }
8375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8376                 if (_ptr_help_file) {
8377                         NDR_PULL_ALLOC(ndr, r->help_file);
8378                 } else {
8379                         r->help_file = NULL;
8380                 }
8381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8382                 if (_ptr_monitor_name) {
8383                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8384                 } else {
8385                         r->monitor_name = NULL;
8386                 }
8387                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8388                 if (_ptr_default_datatype) {
8389                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8390                 } else {
8391                         r->default_datatype = NULL;
8392                 }
8393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8394                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8395                 if (_ptr_dependent_files) {
8396                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8397                 } else {
8398                         r->dependent_files = NULL;
8399                 }
8400                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8401         }
8402         if (ndr_flags & NDR_BUFFERS) {
8403                 if (r->driver_name) {
8404                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8405                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8406                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8407                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8408                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8409                                 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));
8410                         }
8411                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8412                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8414                 }
8415                 if (r->architecture) {
8416                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8417                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8418                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8419                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8420                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8421                                 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));
8422                         }
8423                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8424                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8425                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8426                 }
8427                 if (r->driver_path) {
8428                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8429                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8430                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8431                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8432                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8433                                 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));
8434                         }
8435                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8436                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8438                 }
8439                 if (r->data_file) {
8440                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8441                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8442                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8443                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8444                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8445                                 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));
8446                         }
8447                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8448                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8450                 }
8451                 if (r->config_file) {
8452                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8453                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8454                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8455                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8456                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8457                                 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));
8458                         }
8459                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8460                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8461                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8462                 }
8463                 if (r->help_file) {
8464                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8465                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8466                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8467                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8468                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8469                                 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));
8470                         }
8471                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8472                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8474                 }
8475                 if (r->monitor_name) {
8476                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8477                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8478                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8479                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8480                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8481                                 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));
8482                         }
8483                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8484                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8486                 }
8487                 if (r->default_datatype) {
8488                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8489                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8490                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8491                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8492                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8493                                 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));
8494                         }
8495                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8496                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8498                 }
8499                 if (r->dependent_files) {
8500                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8501                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8502                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8504                 }
8505         }
8506         return NDR_ERR_SUCCESS;
8507 }
8508
8509 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8510 {
8511         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8512         ndr->depth++;
8513         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8514         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8515         ndr->depth++;
8516         if (r->driver_name) {
8517                 ndr_print_string(ndr, "driver_name", r->driver_name);
8518         }
8519         ndr->depth--;
8520         ndr_print_ptr(ndr, "architecture", r->architecture);
8521         ndr->depth++;
8522         if (r->architecture) {
8523                 ndr_print_string(ndr, "architecture", r->architecture);
8524         }
8525         ndr->depth--;
8526         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8527         ndr->depth++;
8528         if (r->driver_path) {
8529                 ndr_print_string(ndr, "driver_path", r->driver_path);
8530         }
8531         ndr->depth--;
8532         ndr_print_ptr(ndr, "data_file", r->data_file);
8533         ndr->depth++;
8534         if (r->data_file) {
8535                 ndr_print_string(ndr, "data_file", r->data_file);
8536         }
8537         ndr->depth--;
8538         ndr_print_ptr(ndr, "config_file", r->config_file);
8539         ndr->depth++;
8540         if (r->config_file) {
8541                 ndr_print_string(ndr, "config_file", r->config_file);
8542         }
8543         ndr->depth--;
8544         ndr_print_ptr(ndr, "help_file", r->help_file);
8545         ndr->depth++;
8546         if (r->help_file) {
8547                 ndr_print_string(ndr, "help_file", r->help_file);
8548         }
8549         ndr->depth--;
8550         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8551         ndr->depth++;
8552         if (r->monitor_name) {
8553                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8554         }
8555         ndr->depth--;
8556         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8557         ndr->depth++;
8558         if (r->default_datatype) {
8559                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8560         }
8561         ndr->depth--;
8562         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);
8563         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8564         ndr->depth++;
8565         if (r->dependent_files) {
8566                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8567         }
8568         ndr->depth--;
8569         ndr->depth--;
8570 }
8571
8572 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8573 {
8574         if (ndr_flags & NDR_SCALARS) {
8575                 NDR_CHECK(ndr_push_align(ndr, 5));
8576                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8577                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8580                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8581                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8583                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8584                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8588                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8589                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8590         }
8591         if (ndr_flags & NDR_BUFFERS) {
8592                 if (r->driver_name) {
8593                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8594                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8595                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8596                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8597                 }
8598                 if (r->architecture) {
8599                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8600                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8601                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8602                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8603                 }
8604                 if (r->driver_path) {
8605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8608                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8609                 }
8610                 if (r->data_file) {
8611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8613                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8614                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8615                 }
8616                 if (r->config_file) {
8617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8618                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8620                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8621                 }
8622                 if (r->help_file) {
8623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8626                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8627                 }
8628                 if (r->monitor_name) {
8629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8632                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8633                 }
8634                 if (r->default_datatype) {
8635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8637                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8638                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8639                 }
8640                 if (r->dependent_files) {
8641                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8642                 }
8643                 if (r->previous_names) {
8644                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8645                 }
8646         }
8647         return NDR_ERR_SUCCESS;
8648 }
8649
8650 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8651 {
8652         uint32_t _ptr_driver_name;
8653         TALLOC_CTX *_mem_save_driver_name_0;
8654         uint32_t _ptr_architecture;
8655         TALLOC_CTX *_mem_save_architecture_0;
8656         uint32_t _ptr_driver_path;
8657         TALLOC_CTX *_mem_save_driver_path_0;
8658         uint32_t _ptr_data_file;
8659         TALLOC_CTX *_mem_save_data_file_0;
8660         uint32_t _ptr_config_file;
8661         TALLOC_CTX *_mem_save_config_file_0;
8662         uint32_t _ptr_help_file;
8663         TALLOC_CTX *_mem_save_help_file_0;
8664         uint32_t _ptr_monitor_name;
8665         TALLOC_CTX *_mem_save_monitor_name_0;
8666         uint32_t _ptr_default_datatype;
8667         TALLOC_CTX *_mem_save_default_datatype_0;
8668         uint32_t _ptr_dependent_files;
8669         TALLOC_CTX *_mem_save_dependent_files_0;
8670         uint32_t _ptr_previous_names;
8671         TALLOC_CTX *_mem_save_previous_names_0;
8672         if (ndr_flags & NDR_SCALARS) {
8673                 NDR_CHECK(ndr_pull_align(ndr, 5));
8674                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8675                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8676                 if (_ptr_driver_name) {
8677                         NDR_PULL_ALLOC(ndr, r->driver_name);
8678                 } else {
8679                         r->driver_name = NULL;
8680                 }
8681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8682                 if (_ptr_architecture) {
8683                         NDR_PULL_ALLOC(ndr, r->architecture);
8684                 } else {
8685                         r->architecture = NULL;
8686                 }
8687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8688                 if (_ptr_driver_path) {
8689                         NDR_PULL_ALLOC(ndr, r->driver_path);
8690                 } else {
8691                         r->driver_path = NULL;
8692                 }
8693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8694                 if (_ptr_data_file) {
8695                         NDR_PULL_ALLOC(ndr, r->data_file);
8696                 } else {
8697                         r->data_file = NULL;
8698                 }
8699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8700                 if (_ptr_config_file) {
8701                         NDR_PULL_ALLOC(ndr, r->config_file);
8702                 } else {
8703                         r->config_file = NULL;
8704                 }
8705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8706                 if (_ptr_help_file) {
8707                         NDR_PULL_ALLOC(ndr, r->help_file);
8708                 } else {
8709                         r->help_file = NULL;
8710                 }
8711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8712                 if (_ptr_monitor_name) {
8713                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8714                 } else {
8715                         r->monitor_name = NULL;
8716                 }
8717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8718                 if (_ptr_default_datatype) {
8719                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8720                 } else {
8721                         r->default_datatype = NULL;
8722                 }
8723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8725                 if (_ptr_dependent_files) {
8726                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8727                 } else {
8728                         r->dependent_files = NULL;
8729                 }
8730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8732                 if (_ptr_previous_names) {
8733                         NDR_PULL_ALLOC(ndr, r->previous_names);
8734                 } else {
8735                         r->previous_names = NULL;
8736                 }
8737                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8738         }
8739         if (ndr_flags & NDR_BUFFERS) {
8740                 if (r->driver_name) {
8741                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8742                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8743                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8744                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8745                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8746                                 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));
8747                         }
8748                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8749                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8751                 }
8752                 if (r->architecture) {
8753                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8754                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8757                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8758                                 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));
8759                         }
8760                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8761                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8763                 }
8764                 if (r->driver_path) {
8765                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8766                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8768                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8769                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8770                                 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));
8771                         }
8772                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8773                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8775                 }
8776                 if (r->data_file) {
8777                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8778                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8780                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8781                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8782                                 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));
8783                         }
8784                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8785                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8787                 }
8788                 if (r->config_file) {
8789                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8790                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8793                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8794                                 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));
8795                         }
8796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8799                 }
8800                 if (r->help_file) {
8801                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8802                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8805                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8806                                 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));
8807                         }
8808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8811                 }
8812                 if (r->monitor_name) {
8813                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8814                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8817                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8818                                 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));
8819                         }
8820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8821                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8823                 }
8824                 if (r->default_datatype) {
8825                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8826                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8827                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8828                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8829                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8830                                 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));
8831                         }
8832                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8833                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8835                 }
8836                 if (r->dependent_files) {
8837                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8838                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8839                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8841                 }
8842                 if (r->previous_names) {
8843                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8844                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8845                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8847                 }
8848         }
8849         return NDR_ERR_SUCCESS;
8850 }
8851
8852 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8853 {
8854         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8855         ndr->depth++;
8856         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8857         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8858         ndr->depth++;
8859         if (r->driver_name) {
8860                 ndr_print_string(ndr, "driver_name", r->driver_name);
8861         }
8862         ndr->depth--;
8863         ndr_print_ptr(ndr, "architecture", r->architecture);
8864         ndr->depth++;
8865         if (r->architecture) {
8866                 ndr_print_string(ndr, "architecture", r->architecture);
8867         }
8868         ndr->depth--;
8869         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8870         ndr->depth++;
8871         if (r->driver_path) {
8872                 ndr_print_string(ndr, "driver_path", r->driver_path);
8873         }
8874         ndr->depth--;
8875         ndr_print_ptr(ndr, "data_file", r->data_file);
8876         ndr->depth++;
8877         if (r->data_file) {
8878                 ndr_print_string(ndr, "data_file", r->data_file);
8879         }
8880         ndr->depth--;
8881         ndr_print_ptr(ndr, "config_file", r->config_file);
8882         ndr->depth++;
8883         if (r->config_file) {
8884                 ndr_print_string(ndr, "config_file", r->config_file);
8885         }
8886         ndr->depth--;
8887         ndr_print_ptr(ndr, "help_file", r->help_file);
8888         ndr->depth++;
8889         if (r->help_file) {
8890                 ndr_print_string(ndr, "help_file", r->help_file);
8891         }
8892         ndr->depth--;
8893         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8894         ndr->depth++;
8895         if (r->monitor_name) {
8896                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8897         }
8898         ndr->depth--;
8899         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8900         ndr->depth++;
8901         if (r->default_datatype) {
8902                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8903         }
8904         ndr->depth--;
8905         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);
8906         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8907         ndr->depth++;
8908         if (r->dependent_files) {
8909                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8910         }
8911         ndr->depth--;
8912         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);
8913         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8914         ndr->depth++;
8915         if (r->previous_names) {
8916                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8917         }
8918         ndr->depth--;
8919         ndr->depth--;
8920 }
8921
8922 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8923 {
8924         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8925         return NDR_ERR_SUCCESS;
8926 }
8927
8928 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8929 {
8930         uint32_t v;
8931         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8932         *r = v;
8933         return NDR_ERR_SUCCESS;
8934 }
8935
8936 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8937 {
8938         ndr_print_uint32(ndr, name, r);
8939         ndr->depth++;
8940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8941         ndr->depth--;
8942 }
8943
8944 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8945 {
8946         if (ndr_flags & NDR_SCALARS) {
8947                 NDR_CHECK(ndr_push_align(ndr, 8));
8948                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8950                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8952                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8953                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8954                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8955                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8956                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8958                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8961                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8962                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8967                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
8968         }
8969         if (ndr_flags & NDR_BUFFERS) {
8970                 if (r->driver_name) {
8971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8974                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8975                 }
8976                 if (r->architecture) {
8977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8980                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8981                 }
8982                 if (r->driver_path) {
8983                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8985                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8986                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8987                 }
8988                 if (r->data_file) {
8989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8990                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8991                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8992                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8993                 }
8994                 if (r->config_file) {
8995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8998                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8999                 }
9000                 if (r->help_file) {
9001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9004                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9005                 }
9006                 if (r->monitor_name) {
9007                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9009                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9010                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9011                 }
9012                 if (r->default_datatype) {
9013                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9014                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9015                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9016                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9017                 }
9018                 if (r->dependent_files) {
9019                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9020                 }
9021                 if (r->previous_names) {
9022                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9023                 }
9024                 if (r->manufacturer_name) {
9025                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9029                 }
9030                 if (r->manufacturer_url) {
9031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9035                 }
9036                 if (r->hardware_id) {
9037                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9038                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9040                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9041                 }
9042                 if (r->provider) {
9043                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9044                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9046                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9047                 }
9048         }
9049         return NDR_ERR_SUCCESS;
9050 }
9051
9052 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9053 {
9054         uint32_t _ptr_driver_name;
9055         TALLOC_CTX *_mem_save_driver_name_0;
9056         uint32_t _ptr_architecture;
9057         TALLOC_CTX *_mem_save_architecture_0;
9058         uint32_t _ptr_driver_path;
9059         TALLOC_CTX *_mem_save_driver_path_0;
9060         uint32_t _ptr_data_file;
9061         TALLOC_CTX *_mem_save_data_file_0;
9062         uint32_t _ptr_config_file;
9063         TALLOC_CTX *_mem_save_config_file_0;
9064         uint32_t _ptr_help_file;
9065         TALLOC_CTX *_mem_save_help_file_0;
9066         uint32_t _ptr_monitor_name;
9067         TALLOC_CTX *_mem_save_monitor_name_0;
9068         uint32_t _ptr_default_datatype;
9069         TALLOC_CTX *_mem_save_default_datatype_0;
9070         uint32_t _ptr_dependent_files;
9071         TALLOC_CTX *_mem_save_dependent_files_0;
9072         uint32_t _ptr_previous_names;
9073         TALLOC_CTX *_mem_save_previous_names_0;
9074         uint32_t _ptr_manufacturer_name;
9075         TALLOC_CTX *_mem_save_manufacturer_name_0;
9076         uint32_t _ptr_manufacturer_url;
9077         TALLOC_CTX *_mem_save_manufacturer_url_0;
9078         uint32_t _ptr_hardware_id;
9079         TALLOC_CTX *_mem_save_hardware_id_0;
9080         uint32_t _ptr_provider;
9081         TALLOC_CTX *_mem_save_provider_0;
9082         if (ndr_flags & NDR_SCALARS) {
9083                 NDR_CHECK(ndr_pull_align(ndr, 8));
9084                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9086                 if (_ptr_driver_name) {
9087                         NDR_PULL_ALLOC(ndr, r->driver_name);
9088                 } else {
9089                         r->driver_name = NULL;
9090                 }
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9092                 if (_ptr_architecture) {
9093                         NDR_PULL_ALLOC(ndr, r->architecture);
9094                 } else {
9095                         r->architecture = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9098                 if (_ptr_driver_path) {
9099                         NDR_PULL_ALLOC(ndr, r->driver_path);
9100                 } else {
9101                         r->driver_path = NULL;
9102                 }
9103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9104                 if (_ptr_data_file) {
9105                         NDR_PULL_ALLOC(ndr, r->data_file);
9106                 } else {
9107                         r->data_file = NULL;
9108                 }
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9110                 if (_ptr_config_file) {
9111                         NDR_PULL_ALLOC(ndr, r->config_file);
9112                 } else {
9113                         r->config_file = NULL;
9114                 }
9115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9116                 if (_ptr_help_file) {
9117                         NDR_PULL_ALLOC(ndr, r->help_file);
9118                 } else {
9119                         r->help_file = NULL;
9120                 }
9121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9122                 if (_ptr_monitor_name) {
9123                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9124                 } else {
9125                         r->monitor_name = NULL;
9126                 }
9127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9128                 if (_ptr_default_datatype) {
9129                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9130                 } else {
9131                         r->default_datatype = NULL;
9132                 }
9133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9135                 if (_ptr_dependent_files) {
9136                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9137                 } else {
9138                         r->dependent_files = NULL;
9139                 }
9140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9142                 if (_ptr_previous_names) {
9143                         NDR_PULL_ALLOC(ndr, r->previous_names);
9144                 } else {
9145                         r->previous_names = NULL;
9146                 }
9147                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9148                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9150                 if (_ptr_manufacturer_name) {
9151                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9152                 } else {
9153                         r->manufacturer_name = NULL;
9154                 }
9155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9156                 if (_ptr_manufacturer_url) {
9157                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9158                 } else {
9159                         r->manufacturer_url = NULL;
9160                 }
9161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9162                 if (_ptr_hardware_id) {
9163                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9164                 } else {
9165                         r->hardware_id = NULL;
9166                 }
9167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9168                 if (_ptr_provider) {
9169                         NDR_PULL_ALLOC(ndr, r->provider);
9170                 } else {
9171                         r->provider = NULL;
9172                 }
9173                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9174         }
9175         if (ndr_flags & NDR_BUFFERS) {
9176                 if (r->driver_name) {
9177                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9178                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9180                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9181                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9182                                 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));
9183                         }
9184                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9185                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9187                 }
9188                 if (r->architecture) {
9189                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9190                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9192                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9193                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9194                                 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));
9195                         }
9196                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9197                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9198                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9199                 }
9200                 if (r->driver_path) {
9201                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9202                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9205                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9206                                 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));
9207                         }
9208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9211                 }
9212                 if (r->data_file) {
9213                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9214                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9215                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9216                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9217                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9218                                 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));
9219                         }
9220                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9221                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9222                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9223                 }
9224                 if (r->config_file) {
9225                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9226                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9228                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9229                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9230                                 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));
9231                         }
9232                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9233                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9235                 }
9236                 if (r->help_file) {
9237                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9238                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9241                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9242                                 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));
9243                         }
9244                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9245                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9247                 }
9248                 if (r->monitor_name) {
9249                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9250                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9252                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9253                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9254                                 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));
9255                         }
9256                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9257                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9259                 }
9260                 if (r->default_datatype) {
9261                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9262                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9263                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9264                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9265                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9266                                 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));
9267                         }
9268                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9271                 }
9272                 if (r->dependent_files) {
9273                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9274                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9275                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9277                 }
9278                 if (r->previous_names) {
9279                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9281                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9283                 }
9284                 if (r->manufacturer_name) {
9285                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9286                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9288                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9289                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9290                                 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));
9291                         }
9292                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9293                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9295                 }
9296                 if (r->manufacturer_url) {
9297                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9298                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9301                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9302                                 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));
9303                         }
9304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9307                 }
9308                 if (r->hardware_id) {
9309                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9310                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9313                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9314                                 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));
9315                         }
9316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9317                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9319                 }
9320                 if (r->provider) {
9321                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9322                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9324                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9325                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9326                                 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));
9327                         }
9328                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9329                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9331                 }
9332         }
9333         return NDR_ERR_SUCCESS;
9334 }
9335
9336 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9337 {
9338         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9339         ndr->depth++;
9340         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9341         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9342         ndr->depth++;
9343         if (r->driver_name) {
9344                 ndr_print_string(ndr, "driver_name", r->driver_name);
9345         }
9346         ndr->depth--;
9347         ndr_print_ptr(ndr, "architecture", r->architecture);
9348         ndr->depth++;
9349         if (r->architecture) {
9350                 ndr_print_string(ndr, "architecture", r->architecture);
9351         }
9352         ndr->depth--;
9353         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9354         ndr->depth++;
9355         if (r->driver_path) {
9356                 ndr_print_string(ndr, "driver_path", r->driver_path);
9357         }
9358         ndr->depth--;
9359         ndr_print_ptr(ndr, "data_file", r->data_file);
9360         ndr->depth++;
9361         if (r->data_file) {
9362                 ndr_print_string(ndr, "data_file", r->data_file);
9363         }
9364         ndr->depth--;
9365         ndr_print_ptr(ndr, "config_file", r->config_file);
9366         ndr->depth++;
9367         if (r->config_file) {
9368                 ndr_print_string(ndr, "config_file", r->config_file);
9369         }
9370         ndr->depth--;
9371         ndr_print_ptr(ndr, "help_file", r->help_file);
9372         ndr->depth++;
9373         if (r->help_file) {
9374                 ndr_print_string(ndr, "help_file", r->help_file);
9375         }
9376         ndr->depth--;
9377         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9378         ndr->depth++;
9379         if (r->monitor_name) {
9380                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9381         }
9382         ndr->depth--;
9383         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9384         ndr->depth++;
9385         if (r->default_datatype) {
9386                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9387         }
9388         ndr->depth--;
9389         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);
9390         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9391         ndr->depth++;
9392         if (r->dependent_files) {
9393                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9394         }
9395         ndr->depth--;
9396         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);
9397         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9398         ndr->depth++;
9399         if (r->previous_names) {
9400                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9401         }
9402         ndr->depth--;
9403         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9404         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9405         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9406         ndr->depth++;
9407         if (r->manufacturer_name) {
9408                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9409         }
9410         ndr->depth--;
9411         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9412         ndr->depth++;
9413         if (r->manufacturer_url) {
9414                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9415         }
9416         ndr->depth--;
9417         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9418         ndr->depth++;
9419         if (r->hardware_id) {
9420                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9421         }
9422         ndr->depth--;
9423         ndr_print_ptr(ndr, "provider", r->provider);
9424         ndr->depth++;
9425         if (r->provider) {
9426                 ndr_print_string(ndr, "provider", r->provider);
9427         }
9428         ndr->depth--;
9429         ndr->depth--;
9430 }
9431
9432 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9433 {
9434         if (ndr_flags & NDR_SCALARS) {
9435                 NDR_CHECK(ndr_push_align(ndr, 8));
9436                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9442                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9443                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9444                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9449                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9450                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9451                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9454                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9455                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9456                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9458                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9459                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9462                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9463                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9464                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9465                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9466         }
9467         if (ndr_flags & NDR_BUFFERS) {
9468                 if (r->driver_name) {
9469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9472                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9473                 }
9474                 if (r->architecture) {
9475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9479                 }
9480                 if (r->driver_path) {
9481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9484                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9485                 }
9486                 if (r->data_file) {
9487                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9488                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9490                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9491                 }
9492                 if (r->config_file) {
9493                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9494                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9495                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9496                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9497                 }
9498                 if (r->help_file) {
9499                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9500                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9501                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9502                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9503                 }
9504                 if (r->monitor_name) {
9505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9506                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9507                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9508                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9509                 }
9510                 if (r->default_datatype) {
9511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9512                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9514                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9515                 }
9516                 if (r->dependent_files) {
9517                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9518                 }
9519                 if (r->previous_names) {
9520                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9521                 }
9522                 if (r->manufacturer_name) {
9523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9526                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9527                 }
9528                 if (r->manufacturer_url) {
9529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9531                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9532                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9533                 }
9534                 if (r->hardware_id) {
9535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9538                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9539                 }
9540                 if (r->provider) {
9541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9542                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9543                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9544                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9545                 }
9546                 if (r->print_processor) {
9547                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9548                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9549                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9550                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9551                 }
9552                 if (r->vendor_setup) {
9553                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9554                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9555                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9556                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9557                 }
9558                 if (r->color_profiles) {
9559                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9560                 }
9561                 if (r->inf_path) {
9562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9565                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9566                 }
9567                 if (r->core_driver_dependencies) {
9568                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9569                 }
9570         }
9571         return NDR_ERR_SUCCESS;
9572 }
9573
9574 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9575 {
9576         uint32_t _ptr_driver_name;
9577         TALLOC_CTX *_mem_save_driver_name_0;
9578         uint32_t _ptr_architecture;
9579         TALLOC_CTX *_mem_save_architecture_0;
9580         uint32_t _ptr_driver_path;
9581         TALLOC_CTX *_mem_save_driver_path_0;
9582         uint32_t _ptr_data_file;
9583         TALLOC_CTX *_mem_save_data_file_0;
9584         uint32_t _ptr_config_file;
9585         TALLOC_CTX *_mem_save_config_file_0;
9586         uint32_t _ptr_help_file;
9587         TALLOC_CTX *_mem_save_help_file_0;
9588         uint32_t _ptr_monitor_name;
9589         TALLOC_CTX *_mem_save_monitor_name_0;
9590         uint32_t _ptr_default_datatype;
9591         TALLOC_CTX *_mem_save_default_datatype_0;
9592         uint32_t _ptr_dependent_files;
9593         TALLOC_CTX *_mem_save_dependent_files_0;
9594         uint32_t _ptr_previous_names;
9595         TALLOC_CTX *_mem_save_previous_names_0;
9596         uint32_t _ptr_manufacturer_name;
9597         TALLOC_CTX *_mem_save_manufacturer_name_0;
9598         uint32_t _ptr_manufacturer_url;
9599         TALLOC_CTX *_mem_save_manufacturer_url_0;
9600         uint32_t _ptr_hardware_id;
9601         TALLOC_CTX *_mem_save_hardware_id_0;
9602         uint32_t _ptr_provider;
9603         TALLOC_CTX *_mem_save_provider_0;
9604         uint32_t _ptr_print_processor;
9605         TALLOC_CTX *_mem_save_print_processor_0;
9606         uint32_t _ptr_vendor_setup;
9607         TALLOC_CTX *_mem_save_vendor_setup_0;
9608         uint32_t _ptr_color_profiles;
9609         TALLOC_CTX *_mem_save_color_profiles_0;
9610         uint32_t _ptr_inf_path;
9611         TALLOC_CTX *_mem_save_inf_path_0;
9612         uint32_t _ptr_core_driver_dependencies;
9613         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9614         if (ndr_flags & NDR_SCALARS) {
9615                 NDR_CHECK(ndr_pull_align(ndr, 8));
9616                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9618                 if (_ptr_driver_name) {
9619                         NDR_PULL_ALLOC(ndr, r->driver_name);
9620                 } else {
9621                         r->driver_name = NULL;
9622                 }
9623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9624                 if (_ptr_architecture) {
9625                         NDR_PULL_ALLOC(ndr, r->architecture);
9626                 } else {
9627                         r->architecture = NULL;
9628                 }
9629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9630                 if (_ptr_driver_path) {
9631                         NDR_PULL_ALLOC(ndr, r->driver_path);
9632                 } else {
9633                         r->driver_path = NULL;
9634                 }
9635                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9636                 if (_ptr_data_file) {
9637                         NDR_PULL_ALLOC(ndr, r->data_file);
9638                 } else {
9639                         r->data_file = NULL;
9640                 }
9641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9642                 if (_ptr_config_file) {
9643                         NDR_PULL_ALLOC(ndr, r->config_file);
9644                 } else {
9645                         r->config_file = NULL;
9646                 }
9647                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9648                 if (_ptr_help_file) {
9649                         NDR_PULL_ALLOC(ndr, r->help_file);
9650                 } else {
9651                         r->help_file = NULL;
9652                 }
9653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9654                 if (_ptr_monitor_name) {
9655                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9656                 } else {
9657                         r->monitor_name = NULL;
9658                 }
9659                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9660                 if (_ptr_default_datatype) {
9661                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9662                 } else {
9663                         r->default_datatype = NULL;
9664                 }
9665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9667                 if (_ptr_dependent_files) {
9668                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9669                 } else {
9670                         r->dependent_files = NULL;
9671                 }
9672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9673                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9674                 if (_ptr_previous_names) {
9675                         NDR_PULL_ALLOC(ndr, r->previous_names);
9676                 } else {
9677                         r->previous_names = NULL;
9678                 }
9679                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9680                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9682                 if (_ptr_manufacturer_name) {
9683                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9684                 } else {
9685                         r->manufacturer_name = NULL;
9686                 }
9687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9688                 if (_ptr_manufacturer_url) {
9689                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9690                 } else {
9691                         r->manufacturer_url = NULL;
9692                 }
9693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9694                 if (_ptr_hardware_id) {
9695                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9696                 } else {
9697                         r->hardware_id = NULL;
9698                 }
9699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9700                 if (_ptr_provider) {
9701                         NDR_PULL_ALLOC(ndr, r->provider);
9702                 } else {
9703                         r->provider = NULL;
9704                 }
9705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9706                 if (_ptr_print_processor) {
9707                         NDR_PULL_ALLOC(ndr, r->print_processor);
9708                 } else {
9709                         r->print_processor = NULL;
9710                 }
9711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9712                 if (_ptr_vendor_setup) {
9713                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9714                 } else {
9715                         r->vendor_setup = NULL;
9716                 }
9717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9719                 if (_ptr_color_profiles) {
9720                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9721                 } else {
9722                         r->color_profiles = NULL;
9723                 }
9724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9725                 if (_ptr_inf_path) {
9726                         NDR_PULL_ALLOC(ndr, r->inf_path);
9727                 } else {
9728                         r->inf_path = NULL;
9729                 }
9730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9733                 if (_ptr_core_driver_dependencies) {
9734                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9735                 } else {
9736                         r->core_driver_dependencies = NULL;
9737                 }
9738                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9739                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9740                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9741         }
9742         if (ndr_flags & NDR_BUFFERS) {
9743                 if (r->driver_name) {
9744                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9745                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9746                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9747                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9748                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9749                                 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));
9750                         }
9751                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9752                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9754                 }
9755                 if (r->architecture) {
9756                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9757                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9758                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9759                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9760                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9761                                 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));
9762                         }
9763                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9764                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9766                 }
9767                 if (r->driver_path) {
9768                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9769                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9770                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9771                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9772                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9773                                 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));
9774                         }
9775                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9776                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9778                 }
9779                 if (r->data_file) {
9780                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9781                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9782                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9783                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9784                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9785                                 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));
9786                         }
9787                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9788                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9790                 }
9791                 if (r->config_file) {
9792                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9793                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9794                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9795                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9796                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9797                                 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));
9798                         }
9799                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9800                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9801                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9802                 }
9803                 if (r->help_file) {
9804                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9805                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9806                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9807                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9808                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9809                                 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));
9810                         }
9811                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9812                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9814                 }
9815                 if (r->monitor_name) {
9816                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9817                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9818                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9819                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9820                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9821                                 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));
9822                         }
9823                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9824                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9826                 }
9827                 if (r->default_datatype) {
9828                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9829                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9832                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9833                                 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));
9834                         }
9835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9836                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9838                 }
9839                 if (r->dependent_files) {
9840                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9841                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9842                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9844                 }
9845                 if (r->previous_names) {
9846                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9847                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9848                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9850                 }
9851                 if (r->manufacturer_name) {
9852                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9853                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9855                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9856                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9857                                 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));
9858                         }
9859                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9860                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9861                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9862                 }
9863                 if (r->manufacturer_url) {
9864                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9865                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9868                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9869                                 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));
9870                         }
9871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9874                 }
9875                 if (r->hardware_id) {
9876                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9877                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9878                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9879                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9880                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9881                                 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));
9882                         }
9883                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9884                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9886                 }
9887                 if (r->provider) {
9888                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9889                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9892                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9893                                 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));
9894                         }
9895                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9896                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9898                 }
9899                 if (r->print_processor) {
9900                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9901                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9902                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9903                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9904                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9905                                 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));
9906                         }
9907                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9908                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9910                 }
9911                 if (r->vendor_setup) {
9912                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9913                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9914                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9915                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9916                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9917                                 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));
9918                         }
9919                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9920                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9922                 }
9923                 if (r->color_profiles) {
9924                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9925                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9926                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9928                 }
9929                 if (r->inf_path) {
9930                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9931                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9934                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9935                                 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));
9936                         }
9937                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9938                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9940                 }
9941                 if (r->core_driver_dependencies) {
9942                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9943                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9944                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9945                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9946                 }
9947         }
9948         return NDR_ERR_SUCCESS;
9949 }
9950
9951 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9952 {
9953         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9954         ndr->depth++;
9955         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9956         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9957         ndr->depth++;
9958         if (r->driver_name) {
9959                 ndr_print_string(ndr, "driver_name", r->driver_name);
9960         }
9961         ndr->depth--;
9962         ndr_print_ptr(ndr, "architecture", r->architecture);
9963         ndr->depth++;
9964         if (r->architecture) {
9965                 ndr_print_string(ndr, "architecture", r->architecture);
9966         }
9967         ndr->depth--;
9968         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9969         ndr->depth++;
9970         if (r->driver_path) {
9971                 ndr_print_string(ndr, "driver_path", r->driver_path);
9972         }
9973         ndr->depth--;
9974         ndr_print_ptr(ndr, "data_file", r->data_file);
9975         ndr->depth++;
9976         if (r->data_file) {
9977                 ndr_print_string(ndr, "data_file", r->data_file);
9978         }
9979         ndr->depth--;
9980         ndr_print_ptr(ndr, "config_file", r->config_file);
9981         ndr->depth++;
9982         if (r->config_file) {
9983                 ndr_print_string(ndr, "config_file", r->config_file);
9984         }
9985         ndr->depth--;
9986         ndr_print_ptr(ndr, "help_file", r->help_file);
9987         ndr->depth++;
9988         if (r->help_file) {
9989                 ndr_print_string(ndr, "help_file", r->help_file);
9990         }
9991         ndr->depth--;
9992         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9993         ndr->depth++;
9994         if (r->monitor_name) {
9995                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9996         }
9997         ndr->depth--;
9998         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9999         ndr->depth++;
10000         if (r->default_datatype) {
10001                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10002         }
10003         ndr->depth--;
10004         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);
10005         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10006         ndr->depth++;
10007         if (r->dependent_files) {
10008                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10009         }
10010         ndr->depth--;
10011         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);
10012         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10013         ndr->depth++;
10014         if (r->previous_names) {
10015                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10016         }
10017         ndr->depth--;
10018         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10019         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10020         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10021         ndr->depth++;
10022         if (r->manufacturer_name) {
10023                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10024         }
10025         ndr->depth--;
10026         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10027         ndr->depth++;
10028         if (r->manufacturer_url) {
10029                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10030         }
10031         ndr->depth--;
10032         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10033         ndr->depth++;
10034         if (r->hardware_id) {
10035                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10036         }
10037         ndr->depth--;
10038         ndr_print_ptr(ndr, "provider", r->provider);
10039         ndr->depth++;
10040         if (r->provider) {
10041                 ndr_print_string(ndr, "provider", r->provider);
10042         }
10043         ndr->depth--;
10044         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10045         ndr->depth++;
10046         if (r->print_processor) {
10047                 ndr_print_string(ndr, "print_processor", r->print_processor);
10048         }
10049         ndr->depth--;
10050         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10051         ndr->depth++;
10052         if (r->vendor_setup) {
10053                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10054         }
10055         ndr->depth--;
10056         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);
10057         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10058         ndr->depth++;
10059         if (r->color_profiles) {
10060                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10061         }
10062         ndr->depth--;
10063         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10064         ndr->depth++;
10065         if (r->inf_path) {
10066                 ndr_print_string(ndr, "inf_path", r->inf_path);
10067         }
10068         ndr->depth--;
10069         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10070         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);
10071         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10072         ndr->depth++;
10073         if (r->core_driver_dependencies) {
10074                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10075         }
10076         ndr->depth--;
10077         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10078         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10079         ndr->depth--;
10080 }
10081
10082 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10083 {
10084         if (ndr_flags & NDR_SCALARS) {
10085                 int level = ndr_push_get_switch_value(ndr, r);
10086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10087                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10088                 switch (level) {
10089                         case 1: {
10090                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10091                         break; }
10092
10093                         case 2: {
10094                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10095                         break; }
10096
10097                         case 3: {
10098                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10099                         break; }
10100
10101                         case 4: {
10102                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10103                         break; }
10104
10105                         case 6: {
10106                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10107                         break; }
10108
10109                         case 8: {
10110                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10111                         break; }
10112
10113                         default:
10114                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10115                 }
10116         }
10117         if (ndr_flags & NDR_BUFFERS) {
10118                 int level = ndr_push_get_switch_value(ndr, r);
10119                 switch (level) {
10120                         case 1:
10121                                 if (r->info1) {
10122                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10123                                 }
10124                         break;
10125
10126                         case 2:
10127                                 if (r->info2) {
10128                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10129                                 }
10130                         break;
10131
10132                         case 3:
10133                                 if (r->info3) {
10134                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10135                                 }
10136                         break;
10137
10138                         case 4:
10139                                 if (r->info4) {
10140                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10141                                 }
10142                         break;
10143
10144                         case 6:
10145                                 if (r->info6) {
10146                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10147                                 }
10148                         break;
10149
10150                         case 8:
10151                                 if (r->info8) {
10152                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10153                                 }
10154                         break;
10155
10156                         default:
10157                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10158                 }
10159         }
10160         return NDR_ERR_SUCCESS;
10161 }
10162
10163 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10164 {
10165         int level;
10166         uint32_t _level;
10167         TALLOC_CTX *_mem_save_info1_0;
10168         TALLOC_CTX *_mem_save_info2_0;
10169         TALLOC_CTX *_mem_save_info3_0;
10170         TALLOC_CTX *_mem_save_info4_0;
10171         TALLOC_CTX *_mem_save_info6_0;
10172         TALLOC_CTX *_mem_save_info8_0;
10173         level = ndr_pull_get_switch_value(ndr, r);
10174         if (ndr_flags & NDR_SCALARS) {
10175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10176                 if (_level != level) {
10177                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10178                 }
10179                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10180                 switch (level) {
10181                         case 1: {
10182                                 uint32_t _ptr_info1;
10183                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10184                                 if (_ptr_info1) {
10185                                         NDR_PULL_ALLOC(ndr, r->info1);
10186                                 } else {
10187                                         r->info1 = NULL;
10188                                 }
10189                         break; }
10190
10191                         case 2: {
10192                                 uint32_t _ptr_info2;
10193                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10194                                 if (_ptr_info2) {
10195                                         NDR_PULL_ALLOC(ndr, r->info2);
10196                                 } else {
10197                                         r->info2 = NULL;
10198                                 }
10199                         break; }
10200
10201                         case 3: {
10202                                 uint32_t _ptr_info3;
10203                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10204                                 if (_ptr_info3) {
10205                                         NDR_PULL_ALLOC(ndr, r->info3);
10206                                 } else {
10207                                         r->info3 = NULL;
10208                                 }
10209                         break; }
10210
10211                         case 4: {
10212                                 uint32_t _ptr_info4;
10213                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10214                                 if (_ptr_info4) {
10215                                         NDR_PULL_ALLOC(ndr, r->info4);
10216                                 } else {
10217                                         r->info4 = NULL;
10218                                 }
10219                         break; }
10220
10221                         case 6: {
10222                                 uint32_t _ptr_info6;
10223                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10224                                 if (_ptr_info6) {
10225                                         NDR_PULL_ALLOC(ndr, r->info6);
10226                                 } else {
10227                                         r->info6 = NULL;
10228                                 }
10229                         break; }
10230
10231                         case 8: {
10232                                 uint32_t _ptr_info8;
10233                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10234                                 if (_ptr_info8) {
10235                                         NDR_PULL_ALLOC(ndr, r->info8);
10236                                 } else {
10237                                         r->info8 = NULL;
10238                                 }
10239                         break; }
10240
10241                         default:
10242                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10243                 }
10244         }
10245         if (ndr_flags & NDR_BUFFERS) {
10246                 switch (level) {
10247                         case 1:
10248                                 if (r->info1) {
10249                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10250                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10251                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10252                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10253                                 }
10254                         break;
10255
10256                         case 2:
10257                                 if (r->info2) {
10258                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10259                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10260                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10261                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10262                                 }
10263                         break;
10264
10265                         case 3:
10266                                 if (r->info3) {
10267                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10268                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10269                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10270                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10271                                 }
10272                         break;
10273
10274                         case 4:
10275                                 if (r->info4) {
10276                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10277                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10278                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10279                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10280                                 }
10281                         break;
10282
10283                         case 6:
10284                                 if (r->info6) {
10285                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10286                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10287                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10288                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10289                                 }
10290                         break;
10291
10292                         case 8:
10293                                 if (r->info8) {
10294                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10295                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10296                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10297                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10298                                 }
10299                         break;
10300
10301                         default:
10302                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10303                 }
10304         }
10305         return NDR_ERR_SUCCESS;
10306 }
10307
10308 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10309 {
10310         int level;
10311         level = ndr_print_get_switch_value(ndr, r);
10312         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10313         switch (level) {
10314                 case 1:
10315                         ndr_print_ptr(ndr, "info1", r->info1);
10316                         ndr->depth++;
10317                         if (r->info1) {
10318                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10319                         }
10320                         ndr->depth--;
10321                 break;
10322
10323                 case 2:
10324                         ndr_print_ptr(ndr, "info2", r->info2);
10325                         ndr->depth++;
10326                         if (r->info2) {
10327                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10328                         }
10329                         ndr->depth--;
10330                 break;
10331
10332                 case 3:
10333                         ndr_print_ptr(ndr, "info3", r->info3);
10334                         ndr->depth++;
10335                         if (r->info3) {
10336                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10337                         }
10338                         ndr->depth--;
10339                 break;
10340
10341                 case 4:
10342                         ndr_print_ptr(ndr, "info4", r->info4);
10343                         ndr->depth++;
10344                         if (r->info4) {
10345                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10346                         }
10347                         ndr->depth--;
10348                 break;
10349
10350                 case 6:
10351                         ndr_print_ptr(ndr, "info6", r->info6);
10352                         ndr->depth++;
10353                         if (r->info6) {
10354                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10355                         }
10356                         ndr->depth--;
10357                 break;
10358
10359                 case 8:
10360                         ndr_print_ptr(ndr, "info8", r->info8);
10361                         ndr->depth++;
10362                         if (r->info8) {
10363                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10364                         }
10365                         ndr->depth--;
10366                 break;
10367
10368                 default:
10369                         ndr_print_bad_level(ndr, name, level);
10370         }
10371 }
10372
10373 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10374 {
10375         if (ndr_flags & NDR_SCALARS) {
10376                 NDR_CHECK(ndr_push_align(ndr, 5));
10377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10378                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10379                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10380                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10381         }
10382         if (ndr_flags & NDR_BUFFERS) {
10383                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10384         }
10385         return NDR_ERR_SUCCESS;
10386 }
10387
10388 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10389 {
10390         if (ndr_flags & NDR_SCALARS) {
10391                 NDR_CHECK(ndr_pull_align(ndr, 5));
10392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10393                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10394                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10395                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10396         }
10397         if (ndr_flags & NDR_BUFFERS) {
10398                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10399         }
10400         return NDR_ERR_SUCCESS;
10401 }
10402
10403 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10404 {
10405         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10406         ndr->depth++;
10407         ndr_print_uint32(ndr, "level", r->level);
10408         ndr_print_set_switch_value(ndr, &r->info, r->level);
10409         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10410         ndr->depth--;
10411 }
10412
10413 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10414 {
10415         if (ndr_flags & NDR_SCALARS) {
10416                 NDR_CHECK(ndr_push_align(ndr, 5));
10417                 {
10418                         uint32_t _flags_save_string = ndr->flags;
10419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10420                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10421                         ndr->flags = _flags_save_string;
10422                 }
10423                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10424         }
10425         if (ndr_flags & NDR_BUFFERS) {
10426                 {
10427                         uint32_t _flags_save_string = ndr->flags;
10428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10429                         if (r->driver_name) {
10430                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10431                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10432                         }
10433                         ndr->flags = _flags_save_string;
10434                 }
10435         }
10436         return NDR_ERR_SUCCESS;
10437 }
10438
10439 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10440 {
10441         uint32_t _ptr_driver_name;
10442         TALLOC_CTX *_mem_save_driver_name_0;
10443         if (ndr_flags & NDR_SCALARS) {
10444                 NDR_CHECK(ndr_pull_align(ndr, 5));
10445                 {
10446                         uint32_t _flags_save_string = ndr->flags;
10447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10448                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10449                         if (_ptr_driver_name) {
10450                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10451                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10452                         } else {
10453                                 r->driver_name = NULL;
10454                         }
10455                         ndr->flags = _flags_save_string;
10456                 }
10457                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10458         }
10459         if (ndr_flags & NDR_BUFFERS) {
10460                 {
10461                         uint32_t _flags_save_string = ndr->flags;
10462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10463                         if (r->driver_name) {
10464                                 uint32_t _relative_save_offset;
10465                                 _relative_save_offset = ndr->offset;
10466                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10467                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10468                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10469                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10470                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10471                                 ndr->offset = _relative_save_offset;
10472                         }
10473                         ndr->flags = _flags_save_string;
10474                 }
10475         }
10476         return NDR_ERR_SUCCESS;
10477 }
10478
10479 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10480 {
10481         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10482         ndr->depth++;
10483         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10484         ndr->depth++;
10485         if (r->driver_name) {
10486                 ndr_print_string(ndr, "driver_name", r->driver_name);
10487         }
10488         ndr->depth--;
10489         ndr->depth--;
10490 }
10491
10492 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10493 {
10494         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10495 }
10496
10497 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10498 {
10499         if (ndr_flags & NDR_SCALARS) {
10500                 NDR_CHECK(ndr_push_align(ndr, 5));
10501                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10502                 {
10503                         uint32_t _flags_save_string = ndr->flags;
10504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10505                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10506                         ndr->flags = _flags_save_string;
10507                 }
10508                 {
10509                         uint32_t _flags_save_string = ndr->flags;
10510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10512                         ndr->flags = _flags_save_string;
10513                 }
10514                 {
10515                         uint32_t _flags_save_string = ndr->flags;
10516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10518                         ndr->flags = _flags_save_string;
10519                 }
10520                 {
10521                         uint32_t _flags_save_string = ndr->flags;
10522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10524                         ndr->flags = _flags_save_string;
10525                 }
10526                 {
10527                         uint32_t _flags_save_string = ndr->flags;
10528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10530                         ndr->flags = _flags_save_string;
10531                 }
10532                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10533         }
10534         if (ndr_flags & NDR_BUFFERS) {
10535                 {
10536                         uint32_t _flags_save_string = ndr->flags;
10537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10538                         if (r->driver_name) {
10539                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10540                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10541                         }
10542                         ndr->flags = _flags_save_string;
10543                 }
10544                 {
10545                         uint32_t _flags_save_string = ndr->flags;
10546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10547                         if (r->architecture) {
10548                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10549                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10550                         }
10551                         ndr->flags = _flags_save_string;
10552                 }
10553                 {
10554                         uint32_t _flags_save_string = ndr->flags;
10555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10556                         if (r->driver_path) {
10557                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10558                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10559                         }
10560                         ndr->flags = _flags_save_string;
10561                 }
10562                 {
10563                         uint32_t _flags_save_string = ndr->flags;
10564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10565                         if (r->data_file) {
10566                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10567                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10568                         }
10569                         ndr->flags = _flags_save_string;
10570                 }
10571                 {
10572                         uint32_t _flags_save_string = ndr->flags;
10573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10574                         if (r->config_file) {
10575                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10576                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10577                         }
10578                         ndr->flags = _flags_save_string;
10579                 }
10580         }
10581         return NDR_ERR_SUCCESS;
10582 }
10583
10584 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10585 {
10586         uint32_t _ptr_driver_name;
10587         TALLOC_CTX *_mem_save_driver_name_0;
10588         uint32_t _ptr_architecture;
10589         TALLOC_CTX *_mem_save_architecture_0;
10590         uint32_t _ptr_driver_path;
10591         TALLOC_CTX *_mem_save_driver_path_0;
10592         uint32_t _ptr_data_file;
10593         TALLOC_CTX *_mem_save_data_file_0;
10594         uint32_t _ptr_config_file;
10595         TALLOC_CTX *_mem_save_config_file_0;
10596         if (ndr_flags & NDR_SCALARS) {
10597                 NDR_CHECK(ndr_pull_align(ndr, 5));
10598                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10599                 {
10600                         uint32_t _flags_save_string = ndr->flags;
10601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10602                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10603                         if (_ptr_driver_name) {
10604                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10605                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10606                         } else {
10607                                 r->driver_name = NULL;
10608                         }
10609                         ndr->flags = _flags_save_string;
10610                 }
10611                 {
10612                         uint32_t _flags_save_string = ndr->flags;
10613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10614                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10615                         if (_ptr_architecture) {
10616                                 NDR_PULL_ALLOC(ndr, r->architecture);
10617                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10618                         } else {
10619                                 r->architecture = NULL;
10620                         }
10621                         ndr->flags = _flags_save_string;
10622                 }
10623                 {
10624                         uint32_t _flags_save_string = ndr->flags;
10625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10626                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10627                         if (_ptr_driver_path) {
10628                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10629                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10630                         } else {
10631                                 r->driver_path = NULL;
10632                         }
10633                         ndr->flags = _flags_save_string;
10634                 }
10635                 {
10636                         uint32_t _flags_save_string = ndr->flags;
10637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10638                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10639                         if (_ptr_data_file) {
10640                                 NDR_PULL_ALLOC(ndr, r->data_file);
10641                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10642                         } else {
10643                                 r->data_file = NULL;
10644                         }
10645                         ndr->flags = _flags_save_string;
10646                 }
10647                 {
10648                         uint32_t _flags_save_string = ndr->flags;
10649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10651                         if (_ptr_config_file) {
10652                                 NDR_PULL_ALLOC(ndr, r->config_file);
10653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10654                         } else {
10655                                 r->config_file = NULL;
10656                         }
10657                         ndr->flags = _flags_save_string;
10658                 }
10659                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10660         }
10661         if (ndr_flags & NDR_BUFFERS) {
10662                 {
10663                         uint32_t _flags_save_string = ndr->flags;
10664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10665                         if (r->driver_name) {
10666                                 uint32_t _relative_save_offset;
10667                                 _relative_save_offset = ndr->offset;
10668                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10669                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10670                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10671                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10672                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10673                                 ndr->offset = _relative_save_offset;
10674                         }
10675                         ndr->flags = _flags_save_string;
10676                 }
10677                 {
10678                         uint32_t _flags_save_string = ndr->flags;
10679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10680                         if (r->architecture) {
10681                                 uint32_t _relative_save_offset;
10682                                 _relative_save_offset = ndr->offset;
10683                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10684                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10685                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10686                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10687                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10688                                 ndr->offset = _relative_save_offset;
10689                         }
10690                         ndr->flags = _flags_save_string;
10691                 }
10692                 {
10693                         uint32_t _flags_save_string = ndr->flags;
10694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10695                         if (r->driver_path) {
10696                                 uint32_t _relative_save_offset;
10697                                 _relative_save_offset = ndr->offset;
10698                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10699                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10700                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10701                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10702                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10703                                 ndr->offset = _relative_save_offset;
10704                         }
10705                         ndr->flags = _flags_save_string;
10706                 }
10707                 {
10708                         uint32_t _flags_save_string = ndr->flags;
10709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10710                         if (r->data_file) {
10711                                 uint32_t _relative_save_offset;
10712                                 _relative_save_offset = ndr->offset;
10713                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10714                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10715                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10716                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10717                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10718                                 ndr->offset = _relative_save_offset;
10719                         }
10720                         ndr->flags = _flags_save_string;
10721                 }
10722                 {
10723                         uint32_t _flags_save_string = ndr->flags;
10724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10725                         if (r->config_file) {
10726                                 uint32_t _relative_save_offset;
10727                                 _relative_save_offset = ndr->offset;
10728                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10729                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10730                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10731                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10732                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10733                                 ndr->offset = _relative_save_offset;
10734                         }
10735                         ndr->flags = _flags_save_string;
10736                 }
10737         }
10738         return NDR_ERR_SUCCESS;
10739 }
10740
10741 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10742 {
10743         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10744         ndr->depth++;
10745         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10746         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10747         ndr->depth++;
10748         if (r->driver_name) {
10749                 ndr_print_string(ndr, "driver_name", r->driver_name);
10750         }
10751         ndr->depth--;
10752         ndr_print_ptr(ndr, "architecture", r->architecture);
10753         ndr->depth++;
10754         if (r->architecture) {
10755                 ndr_print_string(ndr, "architecture", r->architecture);
10756         }
10757         ndr->depth--;
10758         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10759         ndr->depth++;
10760         if (r->driver_path) {
10761                 ndr_print_string(ndr, "driver_path", r->driver_path);
10762         }
10763         ndr->depth--;
10764         ndr_print_ptr(ndr, "data_file", r->data_file);
10765         ndr->depth++;
10766         if (r->data_file) {
10767                 ndr_print_string(ndr, "data_file", r->data_file);
10768         }
10769         ndr->depth--;
10770         ndr_print_ptr(ndr, "config_file", r->config_file);
10771         ndr->depth++;
10772         if (r->config_file) {
10773                 ndr_print_string(ndr, "config_file", r->config_file);
10774         }
10775         ndr->depth--;
10776         ndr->depth--;
10777 }
10778
10779 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10780 {
10781         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10782 }
10783
10784 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10785 {
10786         if (ndr_flags & NDR_SCALARS) {
10787                 NDR_CHECK(ndr_push_align(ndr, 5));
10788                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10789                 {
10790                         uint32_t _flags_save_string = ndr->flags;
10791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10792                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10793                         ndr->flags = _flags_save_string;
10794                 }
10795                 {
10796                         uint32_t _flags_save_string = ndr->flags;
10797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10798                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10799                         ndr->flags = _flags_save_string;
10800                 }
10801                 {
10802                         uint32_t _flags_save_string = ndr->flags;
10803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10804                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10805                         ndr->flags = _flags_save_string;
10806                 }
10807                 {
10808                         uint32_t _flags_save_string = ndr->flags;
10809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10810                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10811                         ndr->flags = _flags_save_string;
10812                 }
10813                 {
10814                         uint32_t _flags_save_string = ndr->flags;
10815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10816                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10817                         ndr->flags = _flags_save_string;
10818                 }
10819                 {
10820                         uint32_t _flags_save_string = ndr->flags;
10821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10822                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10823                         ndr->flags = _flags_save_string;
10824                 }
10825                 {
10826                         uint32_t _flags_save_string_array = ndr->flags;
10827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10828                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10829                         ndr->flags = _flags_save_string_array;
10830                 }
10831                 {
10832                         uint32_t _flags_save_string = ndr->flags;
10833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10834                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
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_push_relative_ptr1(ndr, r->default_datatype));
10841                         ndr->flags = _flags_save_string;
10842                 }
10843                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10844         }
10845         if (ndr_flags & NDR_BUFFERS) {
10846                 {
10847                         uint32_t _flags_save_string = ndr->flags;
10848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10849                         if (r->driver_name) {
10850                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10851                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10852                         }
10853                         ndr->flags = _flags_save_string;
10854                 }
10855                 {
10856                         uint32_t _flags_save_string = ndr->flags;
10857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10858                         if (r->architecture) {
10859                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10860                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10861                         }
10862                         ndr->flags = _flags_save_string;
10863                 }
10864                 {
10865                         uint32_t _flags_save_string = ndr->flags;
10866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10867                         if (r->driver_path) {
10868                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10869                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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                         if (r->data_file) {
10877                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10878                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10879                         }
10880                         ndr->flags = _flags_save_string;
10881                 }
10882                 {
10883                         uint32_t _flags_save_string = ndr->flags;
10884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10885                         if (r->config_file) {
10886                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10887                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10888                         }
10889                         ndr->flags = _flags_save_string;
10890                 }
10891                 {
10892                         uint32_t _flags_save_string = ndr->flags;
10893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10894                         if (r->help_file) {
10895                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10896                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10897                         }
10898                         ndr->flags = _flags_save_string;
10899                 }
10900                 {
10901                         uint32_t _flags_save_string_array = ndr->flags;
10902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10903                         if (r->dependent_files) {
10904                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10905                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10906                         }
10907                         ndr->flags = _flags_save_string_array;
10908                 }
10909                 {
10910                         uint32_t _flags_save_string = ndr->flags;
10911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10912                         if (r->monitor_name) {
10913                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10914                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10915                         }
10916                         ndr->flags = _flags_save_string;
10917                 }
10918                 {
10919                         uint32_t _flags_save_string = ndr->flags;
10920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10921                         if (r->default_datatype) {
10922                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10923                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10924                         }
10925                         ndr->flags = _flags_save_string;
10926                 }
10927         }
10928         return NDR_ERR_SUCCESS;
10929 }
10930
10931 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10932 {
10933         uint32_t _ptr_driver_name;
10934         TALLOC_CTX *_mem_save_driver_name_0;
10935         uint32_t _ptr_architecture;
10936         TALLOC_CTX *_mem_save_architecture_0;
10937         uint32_t _ptr_driver_path;
10938         TALLOC_CTX *_mem_save_driver_path_0;
10939         uint32_t _ptr_data_file;
10940         TALLOC_CTX *_mem_save_data_file_0;
10941         uint32_t _ptr_config_file;
10942         TALLOC_CTX *_mem_save_config_file_0;
10943         uint32_t _ptr_help_file;
10944         TALLOC_CTX *_mem_save_help_file_0;
10945         uint32_t _ptr_dependent_files;
10946         TALLOC_CTX *_mem_save_dependent_files_0;
10947         uint32_t _ptr_monitor_name;
10948         TALLOC_CTX *_mem_save_monitor_name_0;
10949         uint32_t _ptr_default_datatype;
10950         TALLOC_CTX *_mem_save_default_datatype_0;
10951         if (ndr_flags & NDR_SCALARS) {
10952                 NDR_CHECK(ndr_pull_align(ndr, 5));
10953                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10954                 {
10955                         uint32_t _flags_save_string = ndr->flags;
10956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10957                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10958                         if (_ptr_driver_name) {
10959                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10960                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10961                         } else {
10962                                 r->driver_name = NULL;
10963                         }
10964                         ndr->flags = _flags_save_string;
10965                 }
10966                 {
10967                         uint32_t _flags_save_string = ndr->flags;
10968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10969                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10970                         if (_ptr_architecture) {
10971                                 NDR_PULL_ALLOC(ndr, r->architecture);
10972                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10973                         } else {
10974                                 r->architecture = NULL;
10975                         }
10976                         ndr->flags = _flags_save_string;
10977                 }
10978                 {
10979                         uint32_t _flags_save_string = ndr->flags;
10980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10981                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10982                         if (_ptr_driver_path) {
10983                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10984                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10985                         } else {
10986                                 r->driver_path = NULL;
10987                         }
10988                         ndr->flags = _flags_save_string;
10989                 }
10990                 {
10991                         uint32_t _flags_save_string = ndr->flags;
10992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10993                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10994                         if (_ptr_data_file) {
10995                                 NDR_PULL_ALLOC(ndr, r->data_file);
10996                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10997                         } else {
10998                                 r->data_file = NULL;
10999                         }
11000                         ndr->flags = _flags_save_string;
11001                 }
11002                 {
11003                         uint32_t _flags_save_string = ndr->flags;
11004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11005                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11006                         if (_ptr_config_file) {
11007                                 NDR_PULL_ALLOC(ndr, r->config_file);
11008                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11009                         } else {
11010                                 r->config_file = NULL;
11011                         }
11012                         ndr->flags = _flags_save_string;
11013                 }
11014                 {
11015                         uint32_t _flags_save_string = ndr->flags;
11016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11017                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11018                         if (_ptr_help_file) {
11019                                 NDR_PULL_ALLOC(ndr, r->help_file);
11020                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11021                         } else {
11022                                 r->help_file = NULL;
11023                         }
11024                         ndr->flags = _flags_save_string;
11025                 }
11026                 {
11027                         uint32_t _flags_save_string_array = ndr->flags;
11028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11029                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11030                         if (_ptr_dependent_files) {
11031                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11032                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11033                         } else {
11034                                 r->dependent_files = NULL;
11035                         }
11036                         ndr->flags = _flags_save_string_array;
11037                 }
11038                 {
11039                         uint32_t _flags_save_string = ndr->flags;
11040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11041                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11042                         if (_ptr_monitor_name) {
11043                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11044                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11045                         } else {
11046                                 r->monitor_name = NULL;
11047                         }
11048                         ndr->flags = _flags_save_string;
11049                 }
11050                 {
11051                         uint32_t _flags_save_string = ndr->flags;
11052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11053                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11054                         if (_ptr_default_datatype) {
11055                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11056                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11057                         } else {
11058                                 r->default_datatype = NULL;
11059                         }
11060                         ndr->flags = _flags_save_string;
11061                 }
11062                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11063         }
11064         if (ndr_flags & NDR_BUFFERS) {
11065                 {
11066                         uint32_t _flags_save_string = ndr->flags;
11067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11068                         if (r->driver_name) {
11069                                 uint32_t _relative_save_offset;
11070                                 _relative_save_offset = ndr->offset;
11071                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11072                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11073                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11074                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11075                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11076                                 ndr->offset = _relative_save_offset;
11077                         }
11078                         ndr->flags = _flags_save_string;
11079                 }
11080                 {
11081                         uint32_t _flags_save_string = ndr->flags;
11082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11083                         if (r->architecture) {
11084                                 uint32_t _relative_save_offset;
11085                                 _relative_save_offset = ndr->offset;
11086                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11087                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11088                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11089                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11090                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11091                                 ndr->offset = _relative_save_offset;
11092                         }
11093                         ndr->flags = _flags_save_string;
11094                 }
11095                 {
11096                         uint32_t _flags_save_string = ndr->flags;
11097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11098                         if (r->driver_path) {
11099                                 uint32_t _relative_save_offset;
11100                                 _relative_save_offset = ndr->offset;
11101                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11102                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11103                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11104                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11105                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11106                                 ndr->offset = _relative_save_offset;
11107                         }
11108                         ndr->flags = _flags_save_string;
11109                 }
11110                 {
11111                         uint32_t _flags_save_string = ndr->flags;
11112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11113                         if (r->data_file) {
11114                                 uint32_t _relative_save_offset;
11115                                 _relative_save_offset = ndr->offset;
11116                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11117                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11118                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11119                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11120                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11121                                 ndr->offset = _relative_save_offset;
11122                         }
11123                         ndr->flags = _flags_save_string;
11124                 }
11125                 {
11126                         uint32_t _flags_save_string = ndr->flags;
11127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11128                         if (r->config_file) {
11129                                 uint32_t _relative_save_offset;
11130                                 _relative_save_offset = ndr->offset;
11131                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11132                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11133                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11134                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11135                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11136                                 ndr->offset = _relative_save_offset;
11137                         }
11138                         ndr->flags = _flags_save_string;
11139                 }
11140                 {
11141                         uint32_t _flags_save_string = ndr->flags;
11142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11143                         if (r->help_file) {
11144                                 uint32_t _relative_save_offset;
11145                                 _relative_save_offset = ndr->offset;
11146                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11147                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11148                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11149                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11150                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11151                                 ndr->offset = _relative_save_offset;
11152                         }
11153                         ndr->flags = _flags_save_string;
11154                 }
11155                 {
11156                         uint32_t _flags_save_string_array = ndr->flags;
11157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11158                         if (r->dependent_files) {
11159                                 uint32_t _relative_save_offset;
11160                                 _relative_save_offset = ndr->offset;
11161                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11162                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11163                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11164                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11165                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11166                                 ndr->offset = _relative_save_offset;
11167                         }
11168                         ndr->flags = _flags_save_string_array;
11169                 }
11170                 {
11171                         uint32_t _flags_save_string = ndr->flags;
11172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11173                         if (r->monitor_name) {
11174                                 uint32_t _relative_save_offset;
11175                                 _relative_save_offset = ndr->offset;
11176                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11177                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11178                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11179                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11180                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11181                                 ndr->offset = _relative_save_offset;
11182                         }
11183                         ndr->flags = _flags_save_string;
11184                 }
11185                 {
11186                         uint32_t _flags_save_string = ndr->flags;
11187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11188                         if (r->default_datatype) {
11189                                 uint32_t _relative_save_offset;
11190                                 _relative_save_offset = ndr->offset;
11191                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11192                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11193                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11194                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11195                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11196                                 ndr->offset = _relative_save_offset;
11197                         }
11198                         ndr->flags = _flags_save_string;
11199                 }
11200         }
11201         return NDR_ERR_SUCCESS;
11202 }
11203
11204 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11205 {
11206         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11207         ndr->depth++;
11208         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11209         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11210         ndr->depth++;
11211         if (r->driver_name) {
11212                 ndr_print_string(ndr, "driver_name", r->driver_name);
11213         }
11214         ndr->depth--;
11215         ndr_print_ptr(ndr, "architecture", r->architecture);
11216         ndr->depth++;
11217         if (r->architecture) {
11218                 ndr_print_string(ndr, "architecture", r->architecture);
11219         }
11220         ndr->depth--;
11221         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11222         ndr->depth++;
11223         if (r->driver_path) {
11224                 ndr_print_string(ndr, "driver_path", r->driver_path);
11225         }
11226         ndr->depth--;
11227         ndr_print_ptr(ndr, "data_file", r->data_file);
11228         ndr->depth++;
11229         if (r->data_file) {
11230                 ndr_print_string(ndr, "data_file", r->data_file);
11231         }
11232         ndr->depth--;
11233         ndr_print_ptr(ndr, "config_file", r->config_file);
11234         ndr->depth++;
11235         if (r->config_file) {
11236                 ndr_print_string(ndr, "config_file", r->config_file);
11237         }
11238         ndr->depth--;
11239         ndr_print_ptr(ndr, "help_file", r->help_file);
11240         ndr->depth++;
11241         if (r->help_file) {
11242                 ndr_print_string(ndr, "help_file", r->help_file);
11243         }
11244         ndr->depth--;
11245         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11246         ndr->depth++;
11247         if (r->dependent_files) {
11248                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11249         }
11250         ndr->depth--;
11251         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11252         ndr->depth++;
11253         if (r->monitor_name) {
11254                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11255         }
11256         ndr->depth--;
11257         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11258         ndr->depth++;
11259         if (r->default_datatype) {
11260                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11261         }
11262         ndr->depth--;
11263         ndr->depth--;
11264 }
11265
11266 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11267 {
11268         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11269 }
11270
11271 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11272 {
11273         if (ndr_flags & NDR_SCALARS) {
11274                 NDR_CHECK(ndr_push_align(ndr, 5));
11275                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11276                 {
11277                         uint32_t _flags_save_string = ndr->flags;
11278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11279                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11280                         ndr->flags = _flags_save_string;
11281                 }
11282                 {
11283                         uint32_t _flags_save_string = ndr->flags;
11284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11285                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11286                         ndr->flags = _flags_save_string;
11287                 }
11288                 {
11289                         uint32_t _flags_save_string = ndr->flags;
11290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11291                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11292                         ndr->flags = _flags_save_string;
11293                 }
11294                 {
11295                         uint32_t _flags_save_string = ndr->flags;
11296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11297                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
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_push_relative_ptr1(ndr, r->config_file));
11304                         ndr->flags = _flags_save_string;
11305                 }
11306                 {
11307                         uint32_t _flags_save_string = ndr->flags;
11308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11309                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11310                         ndr->flags = _flags_save_string;
11311                 }
11312                 {
11313                         uint32_t _flags_save_string_array = ndr->flags;
11314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11315                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11316                         ndr->flags = _flags_save_string_array;
11317                 }
11318                 {
11319                         uint32_t _flags_save_string = ndr->flags;
11320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11321                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11322                         ndr->flags = _flags_save_string;
11323                 }
11324                 {
11325                         uint32_t _flags_save_string = ndr->flags;
11326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11327                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11328                         ndr->flags = _flags_save_string;
11329                 }
11330                 {
11331                         uint32_t _flags_save_string_array = ndr->flags;
11332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11333                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11334                         ndr->flags = _flags_save_string_array;
11335                 }
11336                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11337         }
11338         if (ndr_flags & NDR_BUFFERS) {
11339                 {
11340                         uint32_t _flags_save_string = ndr->flags;
11341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11342                         if (r->driver_name) {
11343                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11344                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11345                         }
11346                         ndr->flags = _flags_save_string;
11347                 }
11348                 {
11349                         uint32_t _flags_save_string = ndr->flags;
11350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11351                         if (r->architecture) {
11352                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11353                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11354                         }
11355                         ndr->flags = _flags_save_string;
11356                 }
11357                 {
11358                         uint32_t _flags_save_string = ndr->flags;
11359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11360                         if (r->driver_path) {
11361                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11363                         }
11364                         ndr->flags = _flags_save_string;
11365                 }
11366                 {
11367                         uint32_t _flags_save_string = ndr->flags;
11368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11369                         if (r->data_file) {
11370                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11371                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11372                         }
11373                         ndr->flags = _flags_save_string;
11374                 }
11375                 {
11376                         uint32_t _flags_save_string = ndr->flags;
11377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11378                         if (r->config_file) {
11379                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11380                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11381                         }
11382                         ndr->flags = _flags_save_string;
11383                 }
11384                 {
11385                         uint32_t _flags_save_string = ndr->flags;
11386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11387                         if (r->help_file) {
11388                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11389                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11390                         }
11391                         ndr->flags = _flags_save_string;
11392                 }
11393                 {
11394                         uint32_t _flags_save_string_array = ndr->flags;
11395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11396                         if (r->dependent_files) {
11397                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11398                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11399                         }
11400                         ndr->flags = _flags_save_string_array;
11401                 }
11402                 {
11403                         uint32_t _flags_save_string = ndr->flags;
11404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11405                         if (r->monitor_name) {
11406                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11407                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11408                         }
11409                         ndr->flags = _flags_save_string;
11410                 }
11411                 {
11412                         uint32_t _flags_save_string = ndr->flags;
11413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11414                         if (r->default_datatype) {
11415                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11416                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11417                         }
11418                         ndr->flags = _flags_save_string;
11419                 }
11420                 {
11421                         uint32_t _flags_save_string_array = ndr->flags;
11422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11423                         if (r->previous_names) {
11424                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11425                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11426                         }
11427                         ndr->flags = _flags_save_string_array;
11428                 }
11429         }
11430         return NDR_ERR_SUCCESS;
11431 }
11432
11433 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11434 {
11435         uint32_t _ptr_driver_name;
11436         TALLOC_CTX *_mem_save_driver_name_0;
11437         uint32_t _ptr_architecture;
11438         TALLOC_CTX *_mem_save_architecture_0;
11439         uint32_t _ptr_driver_path;
11440         TALLOC_CTX *_mem_save_driver_path_0;
11441         uint32_t _ptr_data_file;
11442         TALLOC_CTX *_mem_save_data_file_0;
11443         uint32_t _ptr_config_file;
11444         TALLOC_CTX *_mem_save_config_file_0;
11445         uint32_t _ptr_help_file;
11446         TALLOC_CTX *_mem_save_help_file_0;
11447         uint32_t _ptr_dependent_files;
11448         TALLOC_CTX *_mem_save_dependent_files_0;
11449         uint32_t _ptr_monitor_name;
11450         TALLOC_CTX *_mem_save_monitor_name_0;
11451         uint32_t _ptr_default_datatype;
11452         TALLOC_CTX *_mem_save_default_datatype_0;
11453         uint32_t _ptr_previous_names;
11454         TALLOC_CTX *_mem_save_previous_names_0;
11455         if (ndr_flags & NDR_SCALARS) {
11456                 NDR_CHECK(ndr_pull_align(ndr, 5));
11457                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11458                 {
11459                         uint32_t _flags_save_string = ndr->flags;
11460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11461                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11462                         if (_ptr_driver_name) {
11463                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11464                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11465                         } else {
11466                                 r->driver_name = NULL;
11467                         }
11468                         ndr->flags = _flags_save_string;
11469                 }
11470                 {
11471                         uint32_t _flags_save_string = ndr->flags;
11472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11473                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11474                         if (_ptr_architecture) {
11475                                 NDR_PULL_ALLOC(ndr, r->architecture);
11476                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11477                         } else {
11478                                 r->architecture = NULL;
11479                         }
11480                         ndr->flags = _flags_save_string;
11481                 }
11482                 {
11483                         uint32_t _flags_save_string = ndr->flags;
11484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11485                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11486                         if (_ptr_driver_path) {
11487                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11488                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11489                         } else {
11490                                 r->driver_path = NULL;
11491                         }
11492                         ndr->flags = _flags_save_string;
11493                 }
11494                 {
11495                         uint32_t _flags_save_string = ndr->flags;
11496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11497                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11498                         if (_ptr_data_file) {
11499                                 NDR_PULL_ALLOC(ndr, r->data_file);
11500                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11501                         } else {
11502                                 r->data_file = NULL;
11503                         }
11504                         ndr->flags = _flags_save_string;
11505                 }
11506                 {
11507                         uint32_t _flags_save_string = ndr->flags;
11508                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11509                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11510                         if (_ptr_config_file) {
11511                                 NDR_PULL_ALLOC(ndr, r->config_file);
11512                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11513                         } else {
11514                                 r->config_file = NULL;
11515                         }
11516                         ndr->flags = _flags_save_string;
11517                 }
11518                 {
11519                         uint32_t _flags_save_string = ndr->flags;
11520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11521                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11522                         if (_ptr_help_file) {
11523                                 NDR_PULL_ALLOC(ndr, r->help_file);
11524                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11525                         } else {
11526                                 r->help_file = NULL;
11527                         }
11528                         ndr->flags = _flags_save_string;
11529                 }
11530                 {
11531                         uint32_t _flags_save_string_array = ndr->flags;
11532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11533                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11534                         if (_ptr_dependent_files) {
11535                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11536                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11537                         } else {
11538                                 r->dependent_files = NULL;
11539                         }
11540                         ndr->flags = _flags_save_string_array;
11541                 }
11542                 {
11543                         uint32_t _flags_save_string = ndr->flags;
11544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11545                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11546                         if (_ptr_monitor_name) {
11547                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11548                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11549                         } else {
11550                                 r->monitor_name = NULL;
11551                         }
11552                         ndr->flags = _flags_save_string;
11553                 }
11554                 {
11555                         uint32_t _flags_save_string = ndr->flags;
11556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11557                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11558                         if (_ptr_default_datatype) {
11559                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11560                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11561                         } else {
11562                                 r->default_datatype = NULL;
11563                         }
11564                         ndr->flags = _flags_save_string;
11565                 }
11566                 {
11567                         uint32_t _flags_save_string_array = ndr->flags;
11568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11569                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11570                         if (_ptr_previous_names) {
11571                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11572                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11573                         } else {
11574                                 r->previous_names = NULL;
11575                         }
11576                         ndr->flags = _flags_save_string_array;
11577                 }
11578                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11579         }
11580         if (ndr_flags & NDR_BUFFERS) {
11581                 {
11582                         uint32_t _flags_save_string = ndr->flags;
11583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11584                         if (r->driver_name) {
11585                                 uint32_t _relative_save_offset;
11586                                 _relative_save_offset = ndr->offset;
11587                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11588                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11589                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11590                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11591                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11592                                 ndr->offset = _relative_save_offset;
11593                         }
11594                         ndr->flags = _flags_save_string;
11595                 }
11596                 {
11597                         uint32_t _flags_save_string = ndr->flags;
11598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11599                         if (r->architecture) {
11600                                 uint32_t _relative_save_offset;
11601                                 _relative_save_offset = ndr->offset;
11602                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11603                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11604                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11605                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11606                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11607                                 ndr->offset = _relative_save_offset;
11608                         }
11609                         ndr->flags = _flags_save_string;
11610                 }
11611                 {
11612                         uint32_t _flags_save_string = ndr->flags;
11613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11614                         if (r->driver_path) {
11615                                 uint32_t _relative_save_offset;
11616                                 _relative_save_offset = ndr->offset;
11617                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11618                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11619                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11620                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11621                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11622                                 ndr->offset = _relative_save_offset;
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->data_file) {
11630                                 uint32_t _relative_save_offset;
11631                                 _relative_save_offset = ndr->offset;
11632                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11633                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11634                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11635                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11636                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11637                                 ndr->offset = _relative_save_offset;
11638                         }
11639                         ndr->flags = _flags_save_string;
11640                 }
11641                 {
11642                         uint32_t _flags_save_string = ndr->flags;
11643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11644                         if (r->config_file) {
11645                                 uint32_t _relative_save_offset;
11646                                 _relative_save_offset = ndr->offset;
11647                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11648                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11649                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11650                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11651                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11652                                 ndr->offset = _relative_save_offset;
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->help_file) {
11660                                 uint32_t _relative_save_offset;
11661                                 _relative_save_offset = ndr->offset;
11662                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11663                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11664                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11665                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11666                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11667                                 ndr->offset = _relative_save_offset;
11668                         }
11669                         ndr->flags = _flags_save_string;
11670                 }
11671                 {
11672                         uint32_t _flags_save_string_array = ndr->flags;
11673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11674                         if (r->dependent_files) {
11675                                 uint32_t _relative_save_offset;
11676                                 _relative_save_offset = ndr->offset;
11677                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11678                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11679                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11680                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11681                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11682                                 ndr->offset = _relative_save_offset;
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                                 uint32_t _relative_save_offset;
11691                                 _relative_save_offset = ndr->offset;
11692                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11693                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11694                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11695                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11696                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11697                                 ndr->offset = _relative_save_offset;
11698                         }
11699                         ndr->flags = _flags_save_string;
11700                 }
11701                 {
11702                         uint32_t _flags_save_string = ndr->flags;
11703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11704                         if (r->default_datatype) {
11705                                 uint32_t _relative_save_offset;
11706                                 _relative_save_offset = ndr->offset;
11707                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11708                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11709                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11710                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11711                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11712                                 ndr->offset = _relative_save_offset;
11713                         }
11714                         ndr->flags = _flags_save_string;
11715                 }
11716                 {
11717                         uint32_t _flags_save_string_array = ndr->flags;
11718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11719                         if (r->previous_names) {
11720                                 uint32_t _relative_save_offset;
11721                                 _relative_save_offset = ndr->offset;
11722                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11723                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11724                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11725                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11726                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11727                                 ndr->offset = _relative_save_offset;
11728                         }
11729                         ndr->flags = _flags_save_string_array;
11730                 }
11731         }
11732         return NDR_ERR_SUCCESS;
11733 }
11734
11735 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11736 {
11737         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11738         ndr->depth++;
11739         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11740         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11741         ndr->depth++;
11742         if (r->driver_name) {
11743                 ndr_print_string(ndr, "driver_name", r->driver_name);
11744         }
11745         ndr->depth--;
11746         ndr_print_ptr(ndr, "architecture", r->architecture);
11747         ndr->depth++;
11748         if (r->architecture) {
11749                 ndr_print_string(ndr, "architecture", r->architecture);
11750         }
11751         ndr->depth--;
11752         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11753         ndr->depth++;
11754         if (r->driver_path) {
11755                 ndr_print_string(ndr, "driver_path", r->driver_path);
11756         }
11757         ndr->depth--;
11758         ndr_print_ptr(ndr, "data_file", r->data_file);
11759         ndr->depth++;
11760         if (r->data_file) {
11761                 ndr_print_string(ndr, "data_file", r->data_file);
11762         }
11763         ndr->depth--;
11764         ndr_print_ptr(ndr, "config_file", r->config_file);
11765         ndr->depth++;
11766         if (r->config_file) {
11767                 ndr_print_string(ndr, "config_file", r->config_file);
11768         }
11769         ndr->depth--;
11770         ndr_print_ptr(ndr, "help_file", r->help_file);
11771         ndr->depth++;
11772         if (r->help_file) {
11773                 ndr_print_string(ndr, "help_file", r->help_file);
11774         }
11775         ndr->depth--;
11776         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11777         ndr->depth++;
11778         if (r->dependent_files) {
11779                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11780         }
11781         ndr->depth--;
11782         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11783         ndr->depth++;
11784         if (r->monitor_name) {
11785                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11786         }
11787         ndr->depth--;
11788         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11789         ndr->depth++;
11790         if (r->default_datatype) {
11791                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11792         }
11793         ndr->depth--;
11794         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11795         ndr->depth++;
11796         if (r->previous_names) {
11797                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11798         }
11799         ndr->depth--;
11800         ndr->depth--;
11801 }
11802
11803 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11804 {
11805         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11806 }
11807
11808 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11809 {
11810         if (ndr_flags & NDR_SCALARS) {
11811                 NDR_CHECK(ndr_push_align(ndr, 5));
11812                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11813                 {
11814                         uint32_t _flags_save_string = ndr->flags;
11815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11816                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11817                         ndr->flags = _flags_save_string;
11818                 }
11819                 {
11820                         uint32_t _flags_save_string = ndr->flags;
11821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11822                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11823                         ndr->flags = _flags_save_string;
11824                 }
11825                 {
11826                         uint32_t _flags_save_string = ndr->flags;
11827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11828                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11829                         ndr->flags = _flags_save_string;
11830                 }
11831                 {
11832                         uint32_t _flags_save_string = ndr->flags;
11833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11834                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11835                         ndr->flags = _flags_save_string;
11836                 }
11837                 {
11838                         uint32_t _flags_save_string = ndr->flags;
11839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11840                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11841                         ndr->flags = _flags_save_string;
11842                 }
11843                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11846                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11847         }
11848         if (ndr_flags & NDR_BUFFERS) {
11849                 {
11850                         uint32_t _flags_save_string = ndr->flags;
11851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11852                         if (r->driver_name) {
11853                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11854                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11855                         }
11856                         ndr->flags = _flags_save_string;
11857                 }
11858                 {
11859                         uint32_t _flags_save_string = ndr->flags;
11860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11861                         if (r->architecture) {
11862                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11863                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11864                         }
11865                         ndr->flags = _flags_save_string;
11866                 }
11867                 {
11868                         uint32_t _flags_save_string = ndr->flags;
11869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11870                         if (r->driver_path) {
11871                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11872                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11873                         }
11874                         ndr->flags = _flags_save_string;
11875                 }
11876                 {
11877                         uint32_t _flags_save_string = ndr->flags;
11878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11879                         if (r->data_file) {
11880                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11881                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11882                         }
11883                         ndr->flags = _flags_save_string;
11884                 }
11885                 {
11886                         uint32_t _flags_save_string = ndr->flags;
11887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11888                         if (r->config_file) {
11889                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11891                         }
11892                         ndr->flags = _flags_save_string;
11893                 }
11894         }
11895         return NDR_ERR_SUCCESS;
11896 }
11897
11898 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11899 {
11900         uint32_t _ptr_driver_name;
11901         TALLOC_CTX *_mem_save_driver_name_0;
11902         uint32_t _ptr_architecture;
11903         TALLOC_CTX *_mem_save_architecture_0;
11904         uint32_t _ptr_driver_path;
11905         TALLOC_CTX *_mem_save_driver_path_0;
11906         uint32_t _ptr_data_file;
11907         TALLOC_CTX *_mem_save_data_file_0;
11908         uint32_t _ptr_config_file;
11909         TALLOC_CTX *_mem_save_config_file_0;
11910         if (ndr_flags & NDR_SCALARS) {
11911                 NDR_CHECK(ndr_pull_align(ndr, 5));
11912                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11913                 {
11914                         uint32_t _flags_save_string = ndr->flags;
11915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11917                         if (_ptr_driver_name) {
11918                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11920                         } else {
11921                                 r->driver_name = NULL;
11922                         }
11923                         ndr->flags = _flags_save_string;
11924                 }
11925                 {
11926                         uint32_t _flags_save_string = ndr->flags;
11927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11928                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11929                         if (_ptr_architecture) {
11930                                 NDR_PULL_ALLOC(ndr, r->architecture);
11931                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11932                         } else {
11933                                 r->architecture = NULL;
11934                         }
11935                         ndr->flags = _flags_save_string;
11936                 }
11937                 {
11938                         uint32_t _flags_save_string = ndr->flags;
11939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11940                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11941                         if (_ptr_driver_path) {
11942                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11943                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11944                         } else {
11945                                 r->driver_path = NULL;
11946                         }
11947                         ndr->flags = _flags_save_string;
11948                 }
11949                 {
11950                         uint32_t _flags_save_string = ndr->flags;
11951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11952                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11953                         if (_ptr_data_file) {
11954                                 NDR_PULL_ALLOC(ndr, r->data_file);
11955                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11956                         } else {
11957                                 r->data_file = NULL;
11958                         }
11959                         ndr->flags = _flags_save_string;
11960                 }
11961                 {
11962                         uint32_t _flags_save_string = ndr->flags;
11963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11964                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11965                         if (_ptr_config_file) {
11966                                 NDR_PULL_ALLOC(ndr, r->config_file);
11967                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11968                         } else {
11969                                 r->config_file = NULL;
11970                         }
11971                         ndr->flags = _flags_save_string;
11972                 }
11973                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
11974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11976                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11977         }
11978         if (ndr_flags & NDR_BUFFERS) {
11979                 {
11980                         uint32_t _flags_save_string = ndr->flags;
11981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11982                         if (r->driver_name) {
11983                                 uint32_t _relative_save_offset;
11984                                 _relative_save_offset = ndr->offset;
11985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11986                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11987                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11990                                 ndr->offset = _relative_save_offset;
11991                         }
11992                         ndr->flags = _flags_save_string;
11993                 }
11994                 {
11995                         uint32_t _flags_save_string = ndr->flags;
11996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11997                         if (r->architecture) {
11998                                 uint32_t _relative_save_offset;
11999                                 _relative_save_offset = ndr->offset;
12000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12001                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12002                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12005                                 ndr->offset = _relative_save_offset;
12006                         }
12007                         ndr->flags = _flags_save_string;
12008                 }
12009                 {
12010                         uint32_t _flags_save_string = ndr->flags;
12011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12012                         if (r->driver_path) {
12013                                 uint32_t _relative_save_offset;
12014                                 _relative_save_offset = ndr->offset;
12015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12016                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12017                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12020                                 ndr->offset = _relative_save_offset;
12021                         }
12022                         ndr->flags = _flags_save_string;
12023                 }
12024                 {
12025                         uint32_t _flags_save_string = ndr->flags;
12026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12027                         if (r->data_file) {
12028                                 uint32_t _relative_save_offset;
12029                                 _relative_save_offset = ndr->offset;
12030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12031                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12032                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12035                                 ndr->offset = _relative_save_offset;
12036                         }
12037                         ndr->flags = _flags_save_string;
12038                 }
12039                 {
12040                         uint32_t _flags_save_string = ndr->flags;
12041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12042                         if (r->config_file) {
12043                                 uint32_t _relative_save_offset;
12044                                 _relative_save_offset = ndr->offset;
12045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12046                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12047                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12050                                 ndr->offset = _relative_save_offset;
12051                         }
12052                         ndr->flags = _flags_save_string;
12053                 }
12054         }
12055         return NDR_ERR_SUCCESS;
12056 }
12057
12058 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12059 {
12060         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12061         ndr->depth++;
12062         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12063         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12064         ndr->depth++;
12065         if (r->driver_name) {
12066                 ndr_print_string(ndr, "driver_name", r->driver_name);
12067         }
12068         ndr->depth--;
12069         ndr_print_ptr(ndr, "architecture", r->architecture);
12070         ndr->depth++;
12071         if (r->architecture) {
12072                 ndr_print_string(ndr, "architecture", r->architecture);
12073         }
12074         ndr->depth--;
12075         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12076         ndr->depth++;
12077         if (r->driver_path) {
12078                 ndr_print_string(ndr, "driver_path", r->driver_path);
12079         }
12080         ndr->depth--;
12081         ndr_print_ptr(ndr, "data_file", r->data_file);
12082         ndr->depth++;
12083         if (r->data_file) {
12084                 ndr_print_string(ndr, "data_file", r->data_file);
12085         }
12086         ndr->depth--;
12087         ndr_print_ptr(ndr, "config_file", r->config_file);
12088         ndr->depth++;
12089         if (r->config_file) {
12090                 ndr_print_string(ndr, "config_file", r->config_file);
12091         }
12092         ndr->depth--;
12093         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12094         ndr_print_uint32(ndr, "config_version", r->config_version);
12095         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12096         ndr->depth--;
12097 }
12098
12099 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12100 {
12101         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12102 }
12103
12104 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12105 {
12106         if (ndr_flags & NDR_SCALARS) {
12107                 NDR_CHECK(ndr_push_align(ndr, 8));
12108                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12109                 {
12110                         uint32_t _flags_save_string = ndr->flags;
12111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12112                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12113                         ndr->flags = _flags_save_string;
12114                 }
12115                 {
12116                         uint32_t _flags_save_string = ndr->flags;
12117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12118                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12119                         ndr->flags = _flags_save_string;
12120                 }
12121                 {
12122                         uint32_t _flags_save_string = ndr->flags;
12123                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12124                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12125                         ndr->flags = _flags_save_string;
12126                 }
12127                 {
12128                         uint32_t _flags_save_string = ndr->flags;
12129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12130                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12131                         ndr->flags = _flags_save_string;
12132                 }
12133                 {
12134                         uint32_t _flags_save_string = ndr->flags;
12135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12136                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12137                         ndr->flags = _flags_save_string;
12138                 }
12139                 {
12140                         uint32_t _flags_save_string = ndr->flags;
12141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12142                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12143                         ndr->flags = _flags_save_string;
12144                 }
12145                 {
12146                         uint32_t _flags_save_string_array = ndr->flags;
12147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12148                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12149                         ndr->flags = _flags_save_string_array;
12150                 }
12151                 {
12152                         uint32_t _flags_save_string = ndr->flags;
12153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12154                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12155                         ndr->flags = _flags_save_string;
12156                 }
12157                 {
12158                         uint32_t _flags_save_string = ndr->flags;
12159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12160                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12161                         ndr->flags = _flags_save_string;
12162                 }
12163                 {
12164                         uint32_t _flags_save_string_array = ndr->flags;
12165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12166                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12167                         ndr->flags = _flags_save_string_array;
12168                 }
12169                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12170                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12171                 {
12172                         uint32_t _flags_save_string = ndr->flags;
12173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12174                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12175                         ndr->flags = _flags_save_string;
12176                 }
12177                 {
12178                         uint32_t _flags_save_string = ndr->flags;
12179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12180                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12181                         ndr->flags = _flags_save_string;
12182                 }
12183                 {
12184                         uint32_t _flags_save_string = ndr->flags;
12185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12186                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12187                         ndr->flags = _flags_save_string;
12188                 }
12189                 {
12190                         uint32_t _flags_save_string = ndr->flags;
12191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12192                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12193                         ndr->flags = _flags_save_string;
12194                 }
12195                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12196         }
12197         if (ndr_flags & NDR_BUFFERS) {
12198                 {
12199                         uint32_t _flags_save_string = ndr->flags;
12200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12201                         if (r->driver_name) {
12202                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12203                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12204                         }
12205                         ndr->flags = _flags_save_string;
12206                 }
12207                 {
12208                         uint32_t _flags_save_string = ndr->flags;
12209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12210                         if (r->architecture) {
12211                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12212                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12213                         }
12214                         ndr->flags = _flags_save_string;
12215                 }
12216                 {
12217                         uint32_t _flags_save_string = ndr->flags;
12218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12219                         if (r->driver_path) {
12220                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12221                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12222                         }
12223                         ndr->flags = _flags_save_string;
12224                 }
12225                 {
12226                         uint32_t _flags_save_string = ndr->flags;
12227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12228                         if (r->data_file) {
12229                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12230                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12231                         }
12232                         ndr->flags = _flags_save_string;
12233                 }
12234                 {
12235                         uint32_t _flags_save_string = ndr->flags;
12236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12237                         if (r->config_file) {
12238                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12239                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12240                         }
12241                         ndr->flags = _flags_save_string;
12242                 }
12243                 {
12244                         uint32_t _flags_save_string = ndr->flags;
12245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12246                         if (r->help_file) {
12247                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12248                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12249                         }
12250                         ndr->flags = _flags_save_string;
12251                 }
12252                 {
12253                         uint32_t _flags_save_string_array = ndr->flags;
12254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12255                         if (r->dependent_files) {
12256                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12257                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12258                         }
12259                         ndr->flags = _flags_save_string_array;
12260                 }
12261                 {
12262                         uint32_t _flags_save_string = ndr->flags;
12263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12264                         if (r->monitor_name) {
12265                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12266                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12267                         }
12268                         ndr->flags = _flags_save_string;
12269                 }
12270                 {
12271                         uint32_t _flags_save_string = ndr->flags;
12272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12273                         if (r->default_datatype) {
12274                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12275                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12276                         }
12277                         ndr->flags = _flags_save_string;
12278                 }
12279                 {
12280                         uint32_t _flags_save_string_array = ndr->flags;
12281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12282                         if (r->previous_names) {
12283                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12284                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12285                         }
12286                         ndr->flags = _flags_save_string_array;
12287                 }
12288                 {
12289                         uint32_t _flags_save_string = ndr->flags;
12290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12291                         if (r->manufacturer_name) {
12292                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12293                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12294                         }
12295                         ndr->flags = _flags_save_string;
12296                 }
12297                 {
12298                         uint32_t _flags_save_string = ndr->flags;
12299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12300                         if (r->manufacturer_url) {
12301                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12303                         }
12304                         ndr->flags = _flags_save_string;
12305                 }
12306                 {
12307                         uint32_t _flags_save_string = ndr->flags;
12308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12309                         if (r->hardware_id) {
12310                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12311                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12312                         }
12313                         ndr->flags = _flags_save_string;
12314                 }
12315                 {
12316                         uint32_t _flags_save_string = ndr->flags;
12317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12318                         if (r->provider) {
12319                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12320                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12321                         }
12322                         ndr->flags = _flags_save_string;
12323                 }
12324         }
12325         return NDR_ERR_SUCCESS;
12326 }
12327
12328 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12329 {
12330         uint32_t _ptr_driver_name;
12331         TALLOC_CTX *_mem_save_driver_name_0;
12332         uint32_t _ptr_architecture;
12333         TALLOC_CTX *_mem_save_architecture_0;
12334         uint32_t _ptr_driver_path;
12335         TALLOC_CTX *_mem_save_driver_path_0;
12336         uint32_t _ptr_data_file;
12337         TALLOC_CTX *_mem_save_data_file_0;
12338         uint32_t _ptr_config_file;
12339         TALLOC_CTX *_mem_save_config_file_0;
12340         uint32_t _ptr_help_file;
12341         TALLOC_CTX *_mem_save_help_file_0;
12342         uint32_t _ptr_dependent_files;
12343         TALLOC_CTX *_mem_save_dependent_files_0;
12344         uint32_t _ptr_monitor_name;
12345         TALLOC_CTX *_mem_save_monitor_name_0;
12346         uint32_t _ptr_default_datatype;
12347         TALLOC_CTX *_mem_save_default_datatype_0;
12348         uint32_t _ptr_previous_names;
12349         TALLOC_CTX *_mem_save_previous_names_0;
12350         uint32_t _ptr_manufacturer_name;
12351         TALLOC_CTX *_mem_save_manufacturer_name_0;
12352         uint32_t _ptr_manufacturer_url;
12353         TALLOC_CTX *_mem_save_manufacturer_url_0;
12354         uint32_t _ptr_hardware_id;
12355         TALLOC_CTX *_mem_save_hardware_id_0;
12356         uint32_t _ptr_provider;
12357         TALLOC_CTX *_mem_save_provider_0;
12358         if (ndr_flags & NDR_SCALARS) {
12359                 NDR_CHECK(ndr_pull_align(ndr, 8));
12360                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12361                 {
12362                         uint32_t _flags_save_string = ndr->flags;
12363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12364                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12365                         if (_ptr_driver_name) {
12366                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12367                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12368                         } else {
12369                                 r->driver_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12377                         if (_ptr_architecture) {
12378                                 NDR_PULL_ALLOC(ndr, r->architecture);
12379                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12380                         } else {
12381                                 r->architecture = NULL;
12382                         }
12383                         ndr->flags = _flags_save_string;
12384                 }
12385                 {
12386                         uint32_t _flags_save_string = ndr->flags;
12387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12388                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12389                         if (_ptr_driver_path) {
12390                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12391                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12392                         } else {
12393                                 r->driver_path = NULL;
12394                         }
12395                         ndr->flags = _flags_save_string;
12396                 }
12397                 {
12398                         uint32_t _flags_save_string = ndr->flags;
12399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12400                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12401                         if (_ptr_data_file) {
12402                                 NDR_PULL_ALLOC(ndr, r->data_file);
12403                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12404                         } else {
12405                                 r->data_file = NULL;
12406                         }
12407                         ndr->flags = _flags_save_string;
12408                 }
12409                 {
12410                         uint32_t _flags_save_string = ndr->flags;
12411                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12412                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12413                         if (_ptr_config_file) {
12414                                 NDR_PULL_ALLOC(ndr, r->config_file);
12415                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12416                         } else {
12417                                 r->config_file = NULL;
12418                         }
12419                         ndr->flags = _flags_save_string;
12420                 }
12421                 {
12422                         uint32_t _flags_save_string = ndr->flags;
12423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12424                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12425                         if (_ptr_help_file) {
12426                                 NDR_PULL_ALLOC(ndr, r->help_file);
12427                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12428                         } else {
12429                                 r->help_file = NULL;
12430                         }
12431                         ndr->flags = _flags_save_string;
12432                 }
12433                 {
12434                         uint32_t _flags_save_string_array = ndr->flags;
12435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12436                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12437                         if (_ptr_dependent_files) {
12438                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12439                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12440                         } else {
12441                                 r->dependent_files = NULL;
12442                         }
12443                         ndr->flags = _flags_save_string_array;
12444                 }
12445                 {
12446                         uint32_t _flags_save_string = ndr->flags;
12447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12448                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12449                         if (_ptr_monitor_name) {
12450                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12451                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12452                         } else {
12453                                 r->monitor_name = NULL;
12454                         }
12455                         ndr->flags = _flags_save_string;
12456                 }
12457                 {
12458                         uint32_t _flags_save_string = ndr->flags;
12459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12460                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12461                         if (_ptr_default_datatype) {
12462                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12463                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12464                         } else {
12465                                 r->default_datatype = NULL;
12466                         }
12467                         ndr->flags = _flags_save_string;
12468                 }
12469                 {
12470                         uint32_t _flags_save_string_array = ndr->flags;
12471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12472                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12473                         if (_ptr_previous_names) {
12474                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12475                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12476                         } else {
12477                                 r->previous_names = NULL;
12478                         }
12479                         ndr->flags = _flags_save_string_array;
12480                 }
12481                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12482                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12483                 {
12484                         uint32_t _flags_save_string = ndr->flags;
12485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12486                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12487                         if (_ptr_manufacturer_name) {
12488                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12489                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12490                         } else {
12491                                 r->manufacturer_name = NULL;
12492                         }
12493                         ndr->flags = _flags_save_string;
12494                 }
12495                 {
12496                         uint32_t _flags_save_string = ndr->flags;
12497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12498                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12499                         if (_ptr_manufacturer_url) {
12500                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12501                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12502                         } else {
12503                                 r->manufacturer_url = NULL;
12504                         }
12505                         ndr->flags = _flags_save_string;
12506                 }
12507                 {
12508                         uint32_t _flags_save_string = ndr->flags;
12509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12510                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12511                         if (_ptr_hardware_id) {
12512                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12513                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12514                         } else {
12515                                 r->hardware_id = NULL;
12516                         }
12517                         ndr->flags = _flags_save_string;
12518                 }
12519                 {
12520                         uint32_t _flags_save_string = ndr->flags;
12521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12522                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12523                         if (_ptr_provider) {
12524                                 NDR_PULL_ALLOC(ndr, r->provider);
12525                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12526                         } else {
12527                                 r->provider = NULL;
12528                         }
12529                         ndr->flags = _flags_save_string;
12530                 }
12531                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12532         }
12533         if (ndr_flags & NDR_BUFFERS) {
12534                 {
12535                         uint32_t _flags_save_string = ndr->flags;
12536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12537                         if (r->driver_name) {
12538                                 uint32_t _relative_save_offset;
12539                                 _relative_save_offset = ndr->offset;
12540                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12541                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12542                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12543                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12544                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12545                                 ndr->offset = _relative_save_offset;
12546                         }
12547                         ndr->flags = _flags_save_string;
12548                 }
12549                 {
12550                         uint32_t _flags_save_string = ndr->flags;
12551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12552                         if (r->architecture) {
12553                                 uint32_t _relative_save_offset;
12554                                 _relative_save_offset = ndr->offset;
12555                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12556                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12557                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12558                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12559                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12560                                 ndr->offset = _relative_save_offset;
12561                         }
12562                         ndr->flags = _flags_save_string;
12563                 }
12564                 {
12565                         uint32_t _flags_save_string = ndr->flags;
12566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12567                         if (r->driver_path) {
12568                                 uint32_t _relative_save_offset;
12569                                 _relative_save_offset = ndr->offset;
12570                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12571                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12572                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12573                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12574                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12575                                 ndr->offset = _relative_save_offset;
12576                         }
12577                         ndr->flags = _flags_save_string;
12578                 }
12579                 {
12580                         uint32_t _flags_save_string = ndr->flags;
12581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12582                         if (r->data_file) {
12583                                 uint32_t _relative_save_offset;
12584                                 _relative_save_offset = ndr->offset;
12585                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12586                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12587                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12588                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12589                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12590                                 ndr->offset = _relative_save_offset;
12591                         }
12592                         ndr->flags = _flags_save_string;
12593                 }
12594                 {
12595                         uint32_t _flags_save_string = ndr->flags;
12596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12597                         if (r->config_file) {
12598                                 uint32_t _relative_save_offset;
12599                                 _relative_save_offset = ndr->offset;
12600                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12601                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12602                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12603                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12604                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12605                                 ndr->offset = _relative_save_offset;
12606                         }
12607                         ndr->flags = _flags_save_string;
12608                 }
12609                 {
12610                         uint32_t _flags_save_string = ndr->flags;
12611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12612                         if (r->help_file) {
12613                                 uint32_t _relative_save_offset;
12614                                 _relative_save_offset = ndr->offset;
12615                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12616                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12617                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12618                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12619                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12620                                 ndr->offset = _relative_save_offset;
12621                         }
12622                         ndr->flags = _flags_save_string;
12623                 }
12624                 {
12625                         uint32_t _flags_save_string_array = ndr->flags;
12626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12627                         if (r->dependent_files) {
12628                                 uint32_t _relative_save_offset;
12629                                 _relative_save_offset = ndr->offset;
12630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12631                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12632                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12633                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12635                                 ndr->offset = _relative_save_offset;
12636                         }
12637                         ndr->flags = _flags_save_string_array;
12638                 }
12639                 {
12640                         uint32_t _flags_save_string = ndr->flags;
12641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12642                         if (r->monitor_name) {
12643                                 uint32_t _relative_save_offset;
12644                                 _relative_save_offset = ndr->offset;
12645                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12646                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12647                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12648                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12649                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12650                                 ndr->offset = _relative_save_offset;
12651                         }
12652                         ndr->flags = _flags_save_string;
12653                 }
12654                 {
12655                         uint32_t _flags_save_string = ndr->flags;
12656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12657                         if (r->default_datatype) {
12658                                 uint32_t _relative_save_offset;
12659                                 _relative_save_offset = ndr->offset;
12660                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12661                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12662                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12663                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12664                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12665                                 ndr->offset = _relative_save_offset;
12666                         }
12667                         ndr->flags = _flags_save_string;
12668                 }
12669                 {
12670                         uint32_t _flags_save_string_array = ndr->flags;
12671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12672                         if (r->previous_names) {
12673                                 uint32_t _relative_save_offset;
12674                                 _relative_save_offset = ndr->offset;
12675                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12676                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12677                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12678                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12679                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12680                                 ndr->offset = _relative_save_offset;
12681                         }
12682                         ndr->flags = _flags_save_string_array;
12683                 }
12684                 {
12685                         uint32_t _flags_save_string = ndr->flags;
12686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12687                         if (r->manufacturer_name) {
12688                                 uint32_t _relative_save_offset;
12689                                 _relative_save_offset = ndr->offset;
12690                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12691                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12692                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12693                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12694                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12695                                 ndr->offset = _relative_save_offset;
12696                         }
12697                         ndr->flags = _flags_save_string;
12698                 }
12699                 {
12700                         uint32_t _flags_save_string = ndr->flags;
12701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12702                         if (r->manufacturer_url) {
12703                                 uint32_t _relative_save_offset;
12704                                 _relative_save_offset = ndr->offset;
12705                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12706                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12707                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12708                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12709                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12710                                 ndr->offset = _relative_save_offset;
12711                         }
12712                         ndr->flags = _flags_save_string;
12713                 }
12714                 {
12715                         uint32_t _flags_save_string = ndr->flags;
12716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12717                         if (r->hardware_id) {
12718                                 uint32_t _relative_save_offset;
12719                                 _relative_save_offset = ndr->offset;
12720                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12721                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12722                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12723                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12724                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12725                                 ndr->offset = _relative_save_offset;
12726                         }
12727                         ndr->flags = _flags_save_string;
12728                 }
12729                 {
12730                         uint32_t _flags_save_string = ndr->flags;
12731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12732                         if (r->provider) {
12733                                 uint32_t _relative_save_offset;
12734                                 _relative_save_offset = ndr->offset;
12735                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12736                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12737                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12738                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12739                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12740                                 ndr->offset = _relative_save_offset;
12741                         }
12742                         ndr->flags = _flags_save_string;
12743                 }
12744         }
12745         return NDR_ERR_SUCCESS;
12746 }
12747
12748 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12749 {
12750         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12751         ndr->depth++;
12752         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12753         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12754         ndr->depth++;
12755         if (r->driver_name) {
12756                 ndr_print_string(ndr, "driver_name", r->driver_name);
12757         }
12758         ndr->depth--;
12759         ndr_print_ptr(ndr, "architecture", r->architecture);
12760         ndr->depth++;
12761         if (r->architecture) {
12762                 ndr_print_string(ndr, "architecture", r->architecture);
12763         }
12764         ndr->depth--;
12765         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12766         ndr->depth++;
12767         if (r->driver_path) {
12768                 ndr_print_string(ndr, "driver_path", r->driver_path);
12769         }
12770         ndr->depth--;
12771         ndr_print_ptr(ndr, "data_file", r->data_file);
12772         ndr->depth++;
12773         if (r->data_file) {
12774                 ndr_print_string(ndr, "data_file", r->data_file);
12775         }
12776         ndr->depth--;
12777         ndr_print_ptr(ndr, "config_file", r->config_file);
12778         ndr->depth++;
12779         if (r->config_file) {
12780                 ndr_print_string(ndr, "config_file", r->config_file);
12781         }
12782         ndr->depth--;
12783         ndr_print_ptr(ndr, "help_file", r->help_file);
12784         ndr->depth++;
12785         if (r->help_file) {
12786                 ndr_print_string(ndr, "help_file", r->help_file);
12787         }
12788         ndr->depth--;
12789         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12790         ndr->depth++;
12791         if (r->dependent_files) {
12792                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12793         }
12794         ndr->depth--;
12795         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12796         ndr->depth++;
12797         if (r->monitor_name) {
12798                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12799         }
12800         ndr->depth--;
12801         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12802         ndr->depth++;
12803         if (r->default_datatype) {
12804                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12805         }
12806         ndr->depth--;
12807         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12808         ndr->depth++;
12809         if (r->previous_names) {
12810                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12811         }
12812         ndr->depth--;
12813         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12814         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12815         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12816         ndr->depth++;
12817         if (r->manufacturer_name) {
12818                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12819         }
12820         ndr->depth--;
12821         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12822         ndr->depth++;
12823         if (r->manufacturer_url) {
12824                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12825         }
12826         ndr->depth--;
12827         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12828         ndr->depth++;
12829         if (r->hardware_id) {
12830                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12831         }
12832         ndr->depth--;
12833         ndr_print_ptr(ndr, "provider", r->provider);
12834         ndr->depth++;
12835         if (r->provider) {
12836                 ndr_print_string(ndr, "provider", r->provider);
12837         }
12838         ndr->depth--;
12839         ndr->depth--;
12840 }
12841
12842 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12843 {
12844         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12845 }
12846
12847 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12848 {
12849         if (ndr_flags & NDR_SCALARS) {
12850                 NDR_CHECK(ndr_push_align(ndr, 8));
12851                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12852                 {
12853                         uint32_t _flags_save_string = ndr->flags;
12854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12855                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
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_push_relative_ptr1(ndr, r->architecture));
12862                         ndr->flags = _flags_save_string;
12863                 }
12864                 {
12865                         uint32_t _flags_save_string = ndr->flags;
12866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12867                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
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_push_relative_ptr1(ndr, r->data_file));
12874                         ndr->flags = _flags_save_string;
12875                 }
12876                 {
12877                         uint32_t _flags_save_string = ndr->flags;
12878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12879                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12880                         ndr->flags = _flags_save_string;
12881                 }
12882                 {
12883                         uint32_t _flags_save_string = ndr->flags;
12884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12885                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12886                         ndr->flags = _flags_save_string;
12887                 }
12888                 {
12889                         uint32_t _flags_save_string_array = ndr->flags;
12890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12891                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12892                         ndr->flags = _flags_save_string_array;
12893                 }
12894                 {
12895                         uint32_t _flags_save_string = ndr->flags;
12896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12897                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12898                         ndr->flags = _flags_save_string;
12899                 }
12900                 {
12901                         uint32_t _flags_save_string = ndr->flags;
12902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12903                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12904                         ndr->flags = _flags_save_string;
12905                 }
12906                 {
12907                         uint32_t _flags_save_string_array = ndr->flags;
12908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12909                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12910                         ndr->flags = _flags_save_string_array;
12911                 }
12912                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12913                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12914                 {
12915                         uint32_t _flags_save_string = ndr->flags;
12916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12917                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12918                         ndr->flags = _flags_save_string;
12919                 }
12920                 {
12921                         uint32_t _flags_save_string = ndr->flags;
12922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12923                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12924                         ndr->flags = _flags_save_string;
12925                 }
12926                 {
12927                         uint32_t _flags_save_string = ndr->flags;
12928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12929                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12930                         ndr->flags = _flags_save_string;
12931                 }
12932                 {
12933                         uint32_t _flags_save_string = ndr->flags;
12934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12935                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12936                         ndr->flags = _flags_save_string;
12937                 }
12938                 {
12939                         uint32_t _flags_save_string = ndr->flags;
12940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12941                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12942                         ndr->flags = _flags_save_string;
12943                 }
12944                 {
12945                         uint32_t _flags_save_string = ndr->flags;
12946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12947                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12948                         ndr->flags = _flags_save_string;
12949                 }
12950                 {
12951                         uint32_t _flags_save_string_array = ndr->flags;
12952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12953                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12954                         ndr->flags = _flags_save_string_array;
12955                 }
12956                 {
12957                         uint32_t _flags_save_string = ndr->flags;
12958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12959                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12960                         ndr->flags = _flags_save_string;
12961                 }
12962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12963                 {
12964                         uint32_t _flags_save_string_array = ndr->flags;
12965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12966                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12967                         ndr->flags = _flags_save_string_array;
12968                 }
12969                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12970                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12971                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12972         }
12973         if (ndr_flags & NDR_BUFFERS) {
12974                 {
12975                         uint32_t _flags_save_string = ndr->flags;
12976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12977                         if (r->driver_name) {
12978                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12979                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12980                         }
12981                         ndr->flags = _flags_save_string;
12982                 }
12983                 {
12984                         uint32_t _flags_save_string = ndr->flags;
12985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12986                         if (r->architecture) {
12987                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12988                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12989                         }
12990                         ndr->flags = _flags_save_string;
12991                 }
12992                 {
12993                         uint32_t _flags_save_string = ndr->flags;
12994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12995                         if (r->driver_path) {
12996                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12997                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12998                         }
12999                         ndr->flags = _flags_save_string;
13000                 }
13001                 {
13002                         uint32_t _flags_save_string = ndr->flags;
13003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13004                         if (r->data_file) {
13005                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
13006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13007                         }
13008                         ndr->flags = _flags_save_string;
13009                 }
13010                 {
13011                         uint32_t _flags_save_string = ndr->flags;
13012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13013                         if (r->config_file) {
13014                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
13015                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13016                         }
13017                         ndr->flags = _flags_save_string;
13018                 }
13019                 {
13020                         uint32_t _flags_save_string = ndr->flags;
13021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13022                         if (r->help_file) {
13023                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
13024                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13025                         }
13026                         ndr->flags = _flags_save_string;
13027                 }
13028                 {
13029                         uint32_t _flags_save_string_array = ndr->flags;
13030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13031                         if (r->dependent_files) {
13032                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
13033                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13034                         }
13035                         ndr->flags = _flags_save_string_array;
13036                 }
13037                 {
13038                         uint32_t _flags_save_string = ndr->flags;
13039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13040                         if (r->monitor_name) {
13041                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13042                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13043                         }
13044                         ndr->flags = _flags_save_string;
13045                 }
13046                 {
13047                         uint32_t _flags_save_string = ndr->flags;
13048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13049                         if (r->default_datatype) {
13050                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
13051                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13052                         }
13053                         ndr->flags = _flags_save_string;
13054                 }
13055                 {
13056                         uint32_t _flags_save_string_array = ndr->flags;
13057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13058                         if (r->previous_names) {
13059                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
13060                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13061                         }
13062                         ndr->flags = _flags_save_string_array;
13063                 }
13064                 {
13065                         uint32_t _flags_save_string = ndr->flags;
13066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13067                         if (r->manufacturer_name) {
13068                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
13069                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13070                         }
13071                         ndr->flags = _flags_save_string;
13072                 }
13073                 {
13074                         uint32_t _flags_save_string = ndr->flags;
13075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13076                         if (r->manufacturer_url) {
13077                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
13078                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13079                         }
13080                         ndr->flags = _flags_save_string;
13081                 }
13082                 {
13083                         uint32_t _flags_save_string = ndr->flags;
13084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13085                         if (r->hardware_id) {
13086                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
13087                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13088                         }
13089                         ndr->flags = _flags_save_string;
13090                 }
13091                 {
13092                         uint32_t _flags_save_string = ndr->flags;
13093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13094                         if (r->provider) {
13095                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
13096                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13097                         }
13098                         ndr->flags = _flags_save_string;
13099                 }
13100                 {
13101                         uint32_t _flags_save_string = ndr->flags;
13102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13103                         if (r->print_processor) {
13104                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13105                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13106                         }
13107                         ndr->flags = _flags_save_string;
13108                 }
13109                 {
13110                         uint32_t _flags_save_string = ndr->flags;
13111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13112                         if (r->vendor_setup) {
13113                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13114                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13115                         }
13116                         ndr->flags = _flags_save_string;
13117                 }
13118                 {
13119                         uint32_t _flags_save_string_array = ndr->flags;
13120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13121                         if (r->color_profiles) {
13122                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13123                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13124                         }
13125                         ndr->flags = _flags_save_string_array;
13126                 }
13127                 {
13128                         uint32_t _flags_save_string = ndr->flags;
13129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13130                         if (r->inf_path) {
13131                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13132                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13133                         }
13134                         ndr->flags = _flags_save_string;
13135                 }
13136                 {
13137                         uint32_t _flags_save_string_array = ndr->flags;
13138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13139                         if (r->core_driver_dependencies) {
13140                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13141                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13142                         }
13143                         ndr->flags = _flags_save_string_array;
13144                 }
13145         }
13146         return NDR_ERR_SUCCESS;
13147 }
13148
13149 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13150 {
13151         uint32_t _ptr_driver_name;
13152         TALLOC_CTX *_mem_save_driver_name_0;
13153         uint32_t _ptr_architecture;
13154         TALLOC_CTX *_mem_save_architecture_0;
13155         uint32_t _ptr_driver_path;
13156         TALLOC_CTX *_mem_save_driver_path_0;
13157         uint32_t _ptr_data_file;
13158         TALLOC_CTX *_mem_save_data_file_0;
13159         uint32_t _ptr_config_file;
13160         TALLOC_CTX *_mem_save_config_file_0;
13161         uint32_t _ptr_help_file;
13162         TALLOC_CTX *_mem_save_help_file_0;
13163         uint32_t _ptr_dependent_files;
13164         TALLOC_CTX *_mem_save_dependent_files_0;
13165         uint32_t _ptr_monitor_name;
13166         TALLOC_CTX *_mem_save_monitor_name_0;
13167         uint32_t _ptr_default_datatype;
13168         TALLOC_CTX *_mem_save_default_datatype_0;
13169         uint32_t _ptr_previous_names;
13170         TALLOC_CTX *_mem_save_previous_names_0;
13171         uint32_t _ptr_manufacturer_name;
13172         TALLOC_CTX *_mem_save_manufacturer_name_0;
13173         uint32_t _ptr_manufacturer_url;
13174         TALLOC_CTX *_mem_save_manufacturer_url_0;
13175         uint32_t _ptr_hardware_id;
13176         TALLOC_CTX *_mem_save_hardware_id_0;
13177         uint32_t _ptr_provider;
13178         TALLOC_CTX *_mem_save_provider_0;
13179         uint32_t _ptr_print_processor;
13180         TALLOC_CTX *_mem_save_print_processor_0;
13181         uint32_t _ptr_vendor_setup;
13182         TALLOC_CTX *_mem_save_vendor_setup_0;
13183         uint32_t _ptr_color_profiles;
13184         TALLOC_CTX *_mem_save_color_profiles_0;
13185         uint32_t _ptr_inf_path;
13186         TALLOC_CTX *_mem_save_inf_path_0;
13187         uint32_t _ptr_core_driver_dependencies;
13188         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13189         if (ndr_flags & NDR_SCALARS) {
13190                 NDR_CHECK(ndr_pull_align(ndr, 8));
13191                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13192                 {
13193                         uint32_t _flags_save_string = ndr->flags;
13194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13196                         if (_ptr_driver_name) {
13197                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13199                         } else {
13200                                 r->driver_name = NULL;
13201                         }
13202                         ndr->flags = _flags_save_string;
13203                 }
13204                 {
13205                         uint32_t _flags_save_string = ndr->flags;
13206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13207                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13208                         if (_ptr_architecture) {
13209                                 NDR_PULL_ALLOC(ndr, r->architecture);
13210                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13211                         } else {
13212                                 r->architecture = NULL;
13213                         }
13214                         ndr->flags = _flags_save_string;
13215                 }
13216                 {
13217                         uint32_t _flags_save_string = ndr->flags;
13218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13220                         if (_ptr_driver_path) {
13221                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13223                         } else {
13224                                 r->driver_path = NULL;
13225                         }
13226                         ndr->flags = _flags_save_string;
13227                 }
13228                 {
13229                         uint32_t _flags_save_string = ndr->flags;
13230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13231                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13232                         if (_ptr_data_file) {
13233                                 NDR_PULL_ALLOC(ndr, r->data_file);
13234                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13235                         } else {
13236                                 r->data_file = NULL;
13237                         }
13238                         ndr->flags = _flags_save_string;
13239                 }
13240                 {
13241                         uint32_t _flags_save_string = ndr->flags;
13242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13243                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13244                         if (_ptr_config_file) {
13245                                 NDR_PULL_ALLOC(ndr, r->config_file);
13246                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13247                         } else {
13248                                 r->config_file = NULL;
13249                         }
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_pull_generic_ptr(ndr, &_ptr_help_file));
13256                         if (_ptr_help_file) {
13257                                 NDR_PULL_ALLOC(ndr, r->help_file);
13258                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13259                         } else {
13260                                 r->help_file = NULL;
13261                         }
13262                         ndr->flags = _flags_save_string;
13263                 }
13264                 {
13265                         uint32_t _flags_save_string_array = ndr->flags;
13266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13267                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13268                         if (_ptr_dependent_files) {
13269                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13270                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13271                         } else {
13272                                 r->dependent_files = NULL;
13273                         }
13274                         ndr->flags = _flags_save_string_array;
13275                 }
13276                 {
13277                         uint32_t _flags_save_string = ndr->flags;
13278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13279                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13280                         if (_ptr_monitor_name) {
13281                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13282                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13283                         } else {
13284                                 r->monitor_name = NULL;
13285                         }
13286                         ndr->flags = _flags_save_string;
13287                 }
13288                 {
13289                         uint32_t _flags_save_string = ndr->flags;
13290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13291                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13292                         if (_ptr_default_datatype) {
13293                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13294                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13295                         } else {
13296                                 r->default_datatype = NULL;
13297                         }
13298                         ndr->flags = _flags_save_string;
13299                 }
13300                 {
13301                         uint32_t _flags_save_string_array = ndr->flags;
13302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13303                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13304                         if (_ptr_previous_names) {
13305                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13306                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13307                         } else {
13308                                 r->previous_names = NULL;
13309                         }
13310                         ndr->flags = _flags_save_string_array;
13311                 }
13312                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13313                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13314                 {
13315                         uint32_t _flags_save_string = ndr->flags;
13316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13318                         if (_ptr_manufacturer_name) {
13319                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13321                         } else {
13322                                 r->manufacturer_name = NULL;
13323                         }
13324                         ndr->flags = _flags_save_string;
13325                 }
13326                 {
13327                         uint32_t _flags_save_string = ndr->flags;
13328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13330                         if (_ptr_manufacturer_url) {
13331                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13333                         } else {
13334                                 r->manufacturer_url = NULL;
13335                         }
13336                         ndr->flags = _flags_save_string;
13337                 }
13338                 {
13339                         uint32_t _flags_save_string = ndr->flags;
13340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13342                         if (_ptr_hardware_id) {
13343                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13345                         } else {
13346                                 r->hardware_id = NULL;
13347                         }
13348                         ndr->flags = _flags_save_string;
13349                 }
13350                 {
13351                         uint32_t _flags_save_string = ndr->flags;
13352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13354                         if (_ptr_provider) {
13355                                 NDR_PULL_ALLOC(ndr, r->provider);
13356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13357                         } else {
13358                                 r->provider = NULL;
13359                         }
13360                         ndr->flags = _flags_save_string;
13361                 }
13362                 {
13363                         uint32_t _flags_save_string = ndr->flags;
13364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13366                         if (_ptr_print_processor) {
13367                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13369                         } else {
13370                                 r->print_processor = NULL;
13371                         }
13372                         ndr->flags = _flags_save_string;
13373                 }
13374                 {
13375                         uint32_t _flags_save_string = ndr->flags;
13376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13377                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13378                         if (_ptr_vendor_setup) {
13379                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13380                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13381                         } else {
13382                                 r->vendor_setup = NULL;
13383                         }
13384                         ndr->flags = _flags_save_string;
13385                 }
13386                 {
13387                         uint32_t _flags_save_string_array = ndr->flags;
13388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13389                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13390                         if (_ptr_color_profiles) {
13391                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13392                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13393                         } else {
13394                                 r->color_profiles = NULL;
13395                         }
13396                         ndr->flags = _flags_save_string_array;
13397                 }
13398                 {
13399                         uint32_t _flags_save_string = ndr->flags;
13400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13401                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13402                         if (_ptr_inf_path) {
13403                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13404                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13405                         } else {
13406                                 r->inf_path = NULL;
13407                         }
13408                         ndr->flags = _flags_save_string;
13409                 }
13410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13411                 {
13412                         uint32_t _flags_save_string_array = ndr->flags;
13413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13414                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13415                         if (_ptr_core_driver_dependencies) {
13416                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13417                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13418                         } else {
13419                                 r->core_driver_dependencies = NULL;
13420                         }
13421                         ndr->flags = _flags_save_string_array;
13422                 }
13423                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13424                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13425                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13426         }
13427         if (ndr_flags & NDR_BUFFERS) {
13428                 {
13429                         uint32_t _flags_save_string = ndr->flags;
13430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13431                         if (r->driver_name) {
13432                                 uint32_t _relative_save_offset;
13433                                 _relative_save_offset = ndr->offset;
13434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13435                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13436                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13439                                 ndr->offset = _relative_save_offset;
13440                         }
13441                         ndr->flags = _flags_save_string;
13442                 }
13443                 {
13444                         uint32_t _flags_save_string = ndr->flags;
13445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13446                         if (r->architecture) {
13447                                 uint32_t _relative_save_offset;
13448                                 _relative_save_offset = ndr->offset;
13449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13450                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13451                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13454                                 ndr->offset = _relative_save_offset;
13455                         }
13456                         ndr->flags = _flags_save_string;
13457                 }
13458                 {
13459                         uint32_t _flags_save_string = ndr->flags;
13460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13461                         if (r->driver_path) {
13462                                 uint32_t _relative_save_offset;
13463                                 _relative_save_offset = ndr->offset;
13464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13465                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13466                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13469                                 ndr->offset = _relative_save_offset;
13470                         }
13471                         ndr->flags = _flags_save_string;
13472                 }
13473                 {
13474                         uint32_t _flags_save_string = ndr->flags;
13475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13476                         if (r->data_file) {
13477                                 uint32_t _relative_save_offset;
13478                                 _relative_save_offset = ndr->offset;
13479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13480                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13481                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13482                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13484                                 ndr->offset = _relative_save_offset;
13485                         }
13486                         ndr->flags = _flags_save_string;
13487                 }
13488                 {
13489                         uint32_t _flags_save_string = ndr->flags;
13490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13491                         if (r->config_file) {
13492                                 uint32_t _relative_save_offset;
13493                                 _relative_save_offset = ndr->offset;
13494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13495                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13496                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13499                                 ndr->offset = _relative_save_offset;
13500                         }
13501                         ndr->flags = _flags_save_string;
13502                 }
13503                 {
13504                         uint32_t _flags_save_string = ndr->flags;
13505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13506                         if (r->help_file) {
13507                                 uint32_t _relative_save_offset;
13508                                 _relative_save_offset = ndr->offset;
13509                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13510                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13511                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13512                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13513                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13514                                 ndr->offset = _relative_save_offset;
13515                         }
13516                         ndr->flags = _flags_save_string;
13517                 }
13518                 {
13519                         uint32_t _flags_save_string_array = ndr->flags;
13520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13521                         if (r->dependent_files) {
13522                                 uint32_t _relative_save_offset;
13523                                 _relative_save_offset = ndr->offset;
13524                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13525                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13526                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13527                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13528                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13529                                 ndr->offset = _relative_save_offset;
13530                         }
13531                         ndr->flags = _flags_save_string_array;
13532                 }
13533                 {
13534                         uint32_t _flags_save_string = ndr->flags;
13535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13536                         if (r->monitor_name) {
13537                                 uint32_t _relative_save_offset;
13538                                 _relative_save_offset = ndr->offset;
13539                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13540                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13541                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13542                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13543                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13544                                 ndr->offset = _relative_save_offset;
13545                         }
13546                         ndr->flags = _flags_save_string;
13547                 }
13548                 {
13549                         uint32_t _flags_save_string = ndr->flags;
13550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13551                         if (r->default_datatype) {
13552                                 uint32_t _relative_save_offset;
13553                                 _relative_save_offset = ndr->offset;
13554                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13555                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13556                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13557                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13558                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13559                                 ndr->offset = _relative_save_offset;
13560                         }
13561                         ndr->flags = _flags_save_string;
13562                 }
13563                 {
13564                         uint32_t _flags_save_string_array = ndr->flags;
13565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13566                         if (r->previous_names) {
13567                                 uint32_t _relative_save_offset;
13568                                 _relative_save_offset = ndr->offset;
13569                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13570                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13571                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13572                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13573                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13574                                 ndr->offset = _relative_save_offset;
13575                         }
13576                         ndr->flags = _flags_save_string_array;
13577                 }
13578                 {
13579                         uint32_t _flags_save_string = ndr->flags;
13580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13581                         if (r->manufacturer_name) {
13582                                 uint32_t _relative_save_offset;
13583                                 _relative_save_offset = ndr->offset;
13584                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13585                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13586                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13587                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13588                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13589                                 ndr->offset = _relative_save_offset;
13590                         }
13591                         ndr->flags = _flags_save_string;
13592                 }
13593                 {
13594                         uint32_t _flags_save_string = ndr->flags;
13595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13596                         if (r->manufacturer_url) {
13597                                 uint32_t _relative_save_offset;
13598                                 _relative_save_offset = ndr->offset;
13599                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13600                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13601                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13602                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13603                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13604                                 ndr->offset = _relative_save_offset;
13605                         }
13606                         ndr->flags = _flags_save_string;
13607                 }
13608                 {
13609                         uint32_t _flags_save_string = ndr->flags;
13610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13611                         if (r->hardware_id) {
13612                                 uint32_t _relative_save_offset;
13613                                 _relative_save_offset = ndr->offset;
13614                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13615                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13616                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13617                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13618                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13619                                 ndr->offset = _relative_save_offset;
13620                         }
13621                         ndr->flags = _flags_save_string;
13622                 }
13623                 {
13624                         uint32_t _flags_save_string = ndr->flags;
13625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13626                         if (r->provider) {
13627                                 uint32_t _relative_save_offset;
13628                                 _relative_save_offset = ndr->offset;
13629                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13630                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13631                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13632                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13633                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13634                                 ndr->offset = _relative_save_offset;
13635                         }
13636                         ndr->flags = _flags_save_string;
13637                 }
13638                 {
13639                         uint32_t _flags_save_string = ndr->flags;
13640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13641                         if (r->print_processor) {
13642                                 uint32_t _relative_save_offset;
13643                                 _relative_save_offset = ndr->offset;
13644                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13645                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13646                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13647                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13648                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13649                                 ndr->offset = _relative_save_offset;
13650                         }
13651                         ndr->flags = _flags_save_string;
13652                 }
13653                 {
13654                         uint32_t _flags_save_string = ndr->flags;
13655                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13656                         if (r->vendor_setup) {
13657                                 uint32_t _relative_save_offset;
13658                                 _relative_save_offset = ndr->offset;
13659                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13660                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13661                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13662                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13663                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13664                                 ndr->offset = _relative_save_offset;
13665                         }
13666                         ndr->flags = _flags_save_string;
13667                 }
13668                 {
13669                         uint32_t _flags_save_string_array = ndr->flags;
13670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13671                         if (r->color_profiles) {
13672                                 uint32_t _relative_save_offset;
13673                                 _relative_save_offset = ndr->offset;
13674                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13675                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13676                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13677                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13678                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13679                                 ndr->offset = _relative_save_offset;
13680                         }
13681                         ndr->flags = _flags_save_string_array;
13682                 }
13683                 {
13684                         uint32_t _flags_save_string = ndr->flags;
13685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13686                         if (r->inf_path) {
13687                                 uint32_t _relative_save_offset;
13688                                 _relative_save_offset = ndr->offset;
13689                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13690                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13691                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13692                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13693                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13694                                 ndr->offset = _relative_save_offset;
13695                         }
13696                         ndr->flags = _flags_save_string;
13697                 }
13698                 {
13699                         uint32_t _flags_save_string_array = ndr->flags;
13700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13701                         if (r->core_driver_dependencies) {
13702                                 uint32_t _relative_save_offset;
13703                                 _relative_save_offset = ndr->offset;
13704                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13705                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13706                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13707                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13708                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13709                                 ndr->offset = _relative_save_offset;
13710                         }
13711                         ndr->flags = _flags_save_string_array;
13712                 }
13713         }
13714         return NDR_ERR_SUCCESS;
13715 }
13716
13717 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13718 {
13719         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13720         ndr->depth++;
13721         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13722         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13723         ndr->depth++;
13724         if (r->driver_name) {
13725                 ndr_print_string(ndr, "driver_name", r->driver_name);
13726         }
13727         ndr->depth--;
13728         ndr_print_ptr(ndr, "architecture", r->architecture);
13729         ndr->depth++;
13730         if (r->architecture) {
13731                 ndr_print_string(ndr, "architecture", r->architecture);
13732         }
13733         ndr->depth--;
13734         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13735         ndr->depth++;
13736         if (r->driver_path) {
13737                 ndr_print_string(ndr, "driver_path", r->driver_path);
13738         }
13739         ndr->depth--;
13740         ndr_print_ptr(ndr, "data_file", r->data_file);
13741         ndr->depth++;
13742         if (r->data_file) {
13743                 ndr_print_string(ndr, "data_file", r->data_file);
13744         }
13745         ndr->depth--;
13746         ndr_print_ptr(ndr, "config_file", r->config_file);
13747         ndr->depth++;
13748         if (r->config_file) {
13749                 ndr_print_string(ndr, "config_file", r->config_file);
13750         }
13751         ndr->depth--;
13752         ndr_print_ptr(ndr, "help_file", r->help_file);
13753         ndr->depth++;
13754         if (r->help_file) {
13755                 ndr_print_string(ndr, "help_file", r->help_file);
13756         }
13757         ndr->depth--;
13758         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13759         ndr->depth++;
13760         if (r->dependent_files) {
13761                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13762         }
13763         ndr->depth--;
13764         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13765         ndr->depth++;
13766         if (r->monitor_name) {
13767                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13768         }
13769         ndr->depth--;
13770         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13771         ndr->depth++;
13772         if (r->default_datatype) {
13773                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13774         }
13775         ndr->depth--;
13776         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13777         ndr->depth++;
13778         if (r->previous_names) {
13779                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13780         }
13781         ndr->depth--;
13782         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13783         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13784         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13785         ndr->depth++;
13786         if (r->manufacturer_name) {
13787                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13788         }
13789         ndr->depth--;
13790         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13791         ndr->depth++;
13792         if (r->manufacturer_url) {
13793                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13794         }
13795         ndr->depth--;
13796         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13797         ndr->depth++;
13798         if (r->hardware_id) {
13799                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13800         }
13801         ndr->depth--;
13802         ndr_print_ptr(ndr, "provider", r->provider);
13803         ndr->depth++;
13804         if (r->provider) {
13805                 ndr_print_string(ndr, "provider", r->provider);
13806         }
13807         ndr->depth--;
13808         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13809         ndr->depth++;
13810         if (r->print_processor) {
13811                 ndr_print_string(ndr, "print_processor", r->print_processor);
13812         }
13813         ndr->depth--;
13814         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13815         ndr->depth++;
13816         if (r->vendor_setup) {
13817                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13818         }
13819         ndr->depth--;
13820         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13821         ndr->depth++;
13822         if (r->color_profiles) {
13823                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13824         }
13825         ndr->depth--;
13826         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13827         ndr->depth++;
13828         if (r->inf_path) {
13829                 ndr_print_string(ndr, "inf_path", r->inf_path);
13830         }
13831         ndr->depth--;
13832         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13833         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13834         ndr->depth++;
13835         if (r->core_driver_dependencies) {
13836                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13837         }
13838         ndr->depth--;
13839         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13840         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13841         ndr->depth--;
13842 }
13843
13844 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13845 {
13846         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13847 }
13848
13849 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13850 {
13851         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
13852         return NDR_ERR_SUCCESS;
13853 }
13854
13855 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13856 {
13857         uint32_t v;
13858         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
13859         *r = v;
13860         return NDR_ERR_SUCCESS;
13861 }
13862
13863 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13864 {
13865         const char *val = NULL;
13866
13867         switch (r) {
13868                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13869                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13870                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13871                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13872                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13873         }
13874         ndr_print_enum(ndr, name, "ENUM", val, r);
13875 }
13876
13877 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13878 {
13879         if (ndr_flags & NDR_SCALARS) {
13880                 NDR_CHECK(ndr_push_align(ndr, 5));
13881                 {
13882                         uint32_t _flags_save_string = ndr->flags;
13883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13884                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13885                         ndr->flags = _flags_save_string;
13886                 }
13887                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13889                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13890         }
13891         if (ndr_flags & NDR_BUFFERS) {
13892                 {
13893                         uint32_t _flags_save_string = ndr->flags;
13894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13895                         if (r->file_name) {
13896                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13897                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13898                         }
13899                         ndr->flags = _flags_save_string;
13900                 }
13901         }
13902         return NDR_ERR_SUCCESS;
13903 }
13904
13905 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13906 {
13907         uint32_t _ptr_file_name;
13908         TALLOC_CTX *_mem_save_file_name_0;
13909         if (ndr_flags & NDR_SCALARS) {
13910                 NDR_CHECK(ndr_pull_align(ndr, 5));
13911                 {
13912                         uint32_t _flags_save_string = ndr->flags;
13913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13914                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13915                         if (_ptr_file_name) {
13916                                 NDR_PULL_ALLOC(ndr, r->file_name);
13917                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13918                         } else {
13919                                 r->file_name = NULL;
13920                         }
13921                         ndr->flags = _flags_save_string;
13922                 }
13923                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13925                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13926         }
13927         if (ndr_flags & NDR_BUFFERS) {
13928                 {
13929                         uint32_t _flags_save_string = ndr->flags;
13930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13931                         if (r->file_name) {
13932                                 uint32_t _relative_save_offset;
13933                                 _relative_save_offset = ndr->offset;
13934                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13935                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13936                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13937                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13938                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13939                                 ndr->offset = _relative_save_offset;
13940                         }
13941                         ndr->flags = _flags_save_string;
13942                 }
13943         }
13944         return NDR_ERR_SUCCESS;
13945 }
13946
13947 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13948 {
13949         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13950         ndr->depth++;
13951         ndr_print_ptr(ndr, "file_name", r->file_name);
13952         ndr->depth++;
13953         if (r->file_name) {
13954                 ndr_print_string(ndr, "file_name", r->file_name);
13955         }
13956         ndr->depth--;
13957         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13958         ndr_print_uint32(ndr, "file_version", r->file_version);
13959         ndr->depth--;
13960 }
13961
13962 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13963 {
13964         uint32_t cntr_file_info_1;
13965         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13966         ndr->depth++;
13967         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13968         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13969         ndr->depth++;
13970         if (r->driver_name) {
13971                 ndr_print_string(ndr, "driver_name", r->driver_name);
13972         }
13973         ndr->depth--;
13974         ndr_print_ptr(ndr, "architecture", r->architecture);
13975         ndr->depth++;
13976         if (r->architecture) {
13977                 ndr_print_string(ndr, "architecture", r->architecture);
13978         }
13979         ndr->depth--;
13980         ndr_print_ptr(ndr, "file_info", r->file_info);
13981         ndr->depth++;
13982         if (r->file_info) {
13983                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13984                 ndr->depth++;
13985                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13986                         char *idx_1=NULL;
13987                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13988                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13989                                 free(idx_1);
13990                         }
13991                 }
13992                 ndr->depth--;
13993         }
13994         ndr->depth--;
13995         ndr_print_uint32(ndr, "file_count", r->file_count);
13996         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13997         ndr->depth++;
13998         if (r->monitor_name) {
13999                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14000         }
14001         ndr->depth--;
14002         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14003         ndr->depth++;
14004         if (r->default_datatype) {
14005                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14006         }
14007         ndr->depth--;
14008         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14009         ndr->depth++;
14010         if (r->previous_names) {
14011                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14012         }
14013         ndr->depth--;
14014         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14015         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14016         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14017         ndr->depth++;
14018         if (r->manufacturer_name) {
14019                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14020         }
14021         ndr->depth--;
14022         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14023         ndr->depth++;
14024         if (r->manufacturer_url) {
14025                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14026         }
14027         ndr->depth--;
14028         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14029         ndr->depth++;
14030         if (r->hardware_id) {
14031                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14032         }
14033         ndr->depth--;
14034         ndr_print_ptr(ndr, "provider", r->provider);
14035         ndr->depth++;
14036         if (r->provider) {
14037                 ndr_print_string(ndr, "provider", r->provider);
14038         }
14039         ndr->depth--;
14040         ndr->depth--;
14041 }
14042
14043 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14044 {
14045         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14046 }
14047
14048 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14049 {
14050         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14051         if (ndr_flags & NDR_SCALARS) {
14052                 int level = ndr_push_get_switch_value(ndr, r);
14053                 NDR_CHECK(ndr_push_union_align(ndr, 8));
14054                 switch (level) {
14055                         case 1: {
14056                                 NDR_CHECK(ndr_push_align(ndr, 5));
14057                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14058                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14059                         break; }
14060
14061                         case 2: {
14062                                 NDR_CHECK(ndr_push_align(ndr, 5));
14063                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14064                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14065                         break; }
14066
14067                         case 3: {
14068                                 NDR_CHECK(ndr_push_align(ndr, 5));
14069                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14070                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14071                         break; }
14072
14073                         case 4: {
14074                                 NDR_CHECK(ndr_push_align(ndr, 5));
14075                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14076                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14077                         break; }
14078
14079                         case 5: {
14080                                 NDR_CHECK(ndr_push_align(ndr, 5));
14081                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14082                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14083                         break; }
14084
14085                         case 6: {
14086                                 NDR_CHECK(ndr_push_align(ndr, 8));
14087                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14088                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14089                         break; }
14090
14091                         case 8: {
14092                                 NDR_CHECK(ndr_push_align(ndr, 8));
14093                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14094                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14095                         break; }
14096
14097                         case 101: {
14098                                 NDR_CHECK(ndr_push_align(ndr, 8));
14099                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14100                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14101                         break; }
14102
14103                         default: {
14104                         break; }
14105
14106                 }
14107         }
14108         if (ndr_flags & NDR_BUFFERS) {
14109                 int level = ndr_push_get_switch_value(ndr, r);
14110                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14111                 switch (level) {
14112                         case 1:
14113                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14114                         break;
14115
14116                         case 2:
14117                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14118                         break;
14119
14120                         case 3:
14121                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14122                         break;
14123
14124                         case 4:
14125                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14126                         break;
14127
14128                         case 5:
14129                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14130                         break;
14131
14132                         case 6:
14133                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14134                         break;
14135
14136                         case 8:
14137                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14138                         break;
14139
14140                         case 101:
14141                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14142                         break;
14143
14144                         default:
14145                         break;
14146
14147                 }
14148         }
14149         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14150         return NDR_ERR_SUCCESS;
14151 }
14152
14153 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14154 {
14155         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14156         int level;
14157         level = ndr_pull_get_switch_value(ndr, r);
14158         if (ndr_flags & NDR_SCALARS) {
14159                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14160                 switch (level) {
14161                         case 1: {
14162                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14163                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14164                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14165                         break; }
14166
14167                         case 2: {
14168                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14169                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14170                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14171                         break; }
14172
14173                         case 3: {
14174                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14175                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14176                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14177                         break; }
14178
14179                         case 4: {
14180                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14181                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14182                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14183                         break; }
14184
14185                         case 5: {
14186                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14187                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14188                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14189                         break; }
14190
14191                         case 6: {
14192                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14193                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14194                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14195                         break; }
14196
14197                         case 8: {
14198                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14199                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14200                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14201                         break; }
14202
14203                         case 101: {
14204                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14205                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14206                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14207                         break; }
14208
14209                         default: {
14210                         break; }
14211
14212                 }
14213         }
14214         if (ndr_flags & NDR_BUFFERS) {
14215                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14216                 switch (level) {
14217                         case 1:
14218                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14219                         break;
14220
14221                         case 2:
14222                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14223                         break;
14224
14225                         case 3:
14226                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14227                         break;
14228
14229                         case 4:
14230                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14231                         break;
14232
14233                         case 5:
14234                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14235                         break;
14236
14237                         case 6:
14238                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14239                         break;
14240
14241                         case 8:
14242                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14243                         break;
14244
14245                         case 101:
14246                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14247                         break;
14248
14249                         default:
14250                         break;
14251
14252                 }
14253         }
14254         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14255         return NDR_ERR_SUCCESS;
14256 }
14257
14258 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14259 {
14260         int level;
14261         level = ndr_print_get_switch_value(ndr, r);
14262         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14263         switch (level) {
14264                 case 1:
14265                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14266                 break;
14267
14268                 case 2:
14269                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14270                 break;
14271
14272                 case 3:
14273                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14274                 break;
14275
14276                 case 4:
14277                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14278                 break;
14279
14280                 case 5:
14281                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14282                 break;
14283
14284                 case 6:
14285                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14286                 break;
14287
14288                 case 8:
14289                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14290                 break;
14291
14292                 case 101:
14293                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14294                 break;
14295
14296                 default:
14297                 break;
14298
14299         }
14300 }
14301
14302 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14303 {
14304         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14305 }
14306
14307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14308 {
14309         if (ndr_flags & NDR_SCALARS) {
14310                 NDR_CHECK(ndr_push_align(ndr, 4));
14311                 {
14312                         uint32_t _flags_save_string = ndr->flags;
14313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14314                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14315                         ndr->flags = _flags_save_string;
14316                 }
14317                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14318         }
14319         if (ndr_flags & NDR_BUFFERS) {
14320         }
14321         return NDR_ERR_SUCCESS;
14322 }
14323
14324 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14325 {
14326         if (ndr_flags & NDR_SCALARS) {
14327                 NDR_CHECK(ndr_pull_align(ndr, 4));
14328                 {
14329                         uint32_t _flags_save_string = ndr->flags;
14330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14331                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14332                         ndr->flags = _flags_save_string;
14333                 }
14334                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14335         }
14336         if (ndr_flags & NDR_BUFFERS) {
14337         }
14338         return NDR_ERR_SUCCESS;
14339 }
14340
14341 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14342 {
14343         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14344         ndr->depth++;
14345         ndr_print_string(ndr, "directory_name", r->directory_name);
14346         ndr->depth--;
14347 }
14348
14349 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14350 {
14351         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14352 }
14353
14354 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14355 {
14356         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14357         if (ndr_flags & NDR_SCALARS) {
14358                 int level = ndr_push_get_switch_value(ndr, r);
14359                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14360                 switch (level) {
14361                         case 1: {
14362                                 NDR_CHECK(ndr_push_align(ndr, 4));
14363                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14364                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14365                         break; }
14366
14367                         default: {
14368                                 NDR_CHECK(ndr_push_align(ndr, 4));
14369                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14370                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14371                         break; }
14372
14373                 }
14374         }
14375         if (ndr_flags & NDR_BUFFERS) {
14376                 int level = ndr_push_get_switch_value(ndr, r);
14377                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14378                 switch (level) {
14379                         case 1:
14380                         break;
14381
14382                         default:
14383                         break;
14384
14385                 }
14386         }
14387         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14388         return NDR_ERR_SUCCESS;
14389 }
14390
14391 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14392 {
14393         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14394         int level;
14395         level = ndr_pull_get_switch_value(ndr, r);
14396         if (ndr_flags & NDR_SCALARS) {
14397                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14398                 switch (level) {
14399                         case 1: {
14400                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14401                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14402                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14403                         break; }
14404
14405                         default: {
14406                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14407                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14408                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14409                         break; }
14410
14411                 }
14412         }
14413         if (ndr_flags & NDR_BUFFERS) {
14414                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14415                 switch (level) {
14416                         case 1:
14417                         break;
14418
14419                         default:
14420                         break;
14421
14422                 }
14423         }
14424         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14425         return NDR_ERR_SUCCESS;
14426 }
14427
14428 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14429 {
14430         int level;
14431         level = ndr_print_get_switch_value(ndr, r);
14432         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14433         switch (level) {
14434                 case 1:
14435                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14436                 break;
14437
14438                 default:
14439                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14440                 break;
14441
14442         }
14443 }
14444
14445 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14446 {
14447         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14448 }
14449
14450 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14451 {
14452         if (ndr_flags & NDR_SCALARS) {
14453                 NDR_CHECK(ndr_push_align(ndr, 5));
14454                 {
14455                         uint32_t _flags_save_string = ndr->flags;
14456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14457                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14458                         ndr->flags = _flags_save_string;
14459                 }
14460                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14461         }
14462         if (ndr_flags & NDR_BUFFERS) {
14463                 {
14464                         uint32_t _flags_save_string = ndr->flags;
14465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14466                         if (r->print_processor_name) {
14467                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
14468                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14469                         }
14470                         ndr->flags = _flags_save_string;
14471                 }
14472         }
14473         return NDR_ERR_SUCCESS;
14474 }
14475
14476 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14477 {
14478         uint32_t _ptr_print_processor_name;
14479         TALLOC_CTX *_mem_save_print_processor_name_0;
14480         if (ndr_flags & NDR_SCALARS) {
14481                 NDR_CHECK(ndr_pull_align(ndr, 5));
14482                 {
14483                         uint32_t _flags_save_string = ndr->flags;
14484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14485                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14486                         if (_ptr_print_processor_name) {
14487                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
14488                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14489                         } else {
14490                                 r->print_processor_name = NULL;
14491                         }
14492                         ndr->flags = _flags_save_string;
14493                 }
14494                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14495         }
14496         if (ndr_flags & NDR_BUFFERS) {
14497                 {
14498                         uint32_t _flags_save_string = ndr->flags;
14499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14500                         if (r->print_processor_name) {
14501                                 uint32_t _relative_save_offset;
14502                                 _relative_save_offset = ndr->offset;
14503                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14504                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14505                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14506                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14507                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14508                                 ndr->offset = _relative_save_offset;
14509                         }
14510                         ndr->flags = _flags_save_string;
14511                 }
14512         }
14513         return NDR_ERR_SUCCESS;
14514 }
14515
14516 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14517 {
14518         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14519         ndr->depth++;
14520         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14521         ndr->depth++;
14522         if (r->print_processor_name) {
14523                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14524         }
14525         ndr->depth--;
14526         ndr->depth--;
14527 }
14528
14529 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14530 {
14531         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14532 }
14533
14534 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14535 {
14536         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14537         if (ndr_flags & NDR_SCALARS) {
14538                 int level = ndr_push_get_switch_value(ndr, r);
14539                 NDR_CHECK(ndr_push_union_align(ndr, 5));
14540                 switch (level) {
14541                         case 1: {
14542                                 NDR_CHECK(ndr_push_align(ndr, 5));
14543                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14544                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14545                         break; }
14546
14547                         default: {
14548                         break; }
14549
14550                 }
14551         }
14552         if (ndr_flags & NDR_BUFFERS) {
14553                 int level = ndr_push_get_switch_value(ndr, r);
14554                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14555                 switch (level) {
14556                         case 1:
14557                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14558                         break;
14559
14560                         default:
14561                         break;
14562
14563                 }
14564         }
14565         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14566         return NDR_ERR_SUCCESS;
14567 }
14568
14569 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14570 {
14571         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14572         int level;
14573         level = ndr_pull_get_switch_value(ndr, r);
14574         if (ndr_flags & NDR_SCALARS) {
14575                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14576                 switch (level) {
14577                         case 1: {
14578                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14579                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14580                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14581                         break; }
14582
14583                         default: {
14584                         break; }
14585
14586                 }
14587         }
14588         if (ndr_flags & NDR_BUFFERS) {
14589                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14590                 switch (level) {
14591                         case 1:
14592                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14593                         break;
14594
14595                         default:
14596                         break;
14597
14598                 }
14599         }
14600         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14601         return NDR_ERR_SUCCESS;
14602 }
14603
14604 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14605 {
14606         int level;
14607         level = ndr_print_get_switch_value(ndr, r);
14608         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14609         switch (level) {
14610                 case 1:
14611                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14612                 break;
14613
14614                 default:
14615                 break;
14616
14617         }
14618 }
14619
14620 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14621 {
14622         if (ndr_flags & NDR_SCALARS) {
14623                 NDR_CHECK(ndr_push_align(ndr, 4));
14624                 {
14625                         uint32_t _flags_save_string = ndr->flags;
14626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14627                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14628                         ndr->flags = _flags_save_string;
14629                 }
14630                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14631         }
14632         if (ndr_flags & NDR_BUFFERS) {
14633         }
14634         return NDR_ERR_SUCCESS;
14635 }
14636
14637 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14638 {
14639         if (ndr_flags & NDR_SCALARS) {
14640                 NDR_CHECK(ndr_pull_align(ndr, 4));
14641                 {
14642                         uint32_t _flags_save_string = ndr->flags;
14643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14644                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14645                         ndr->flags = _flags_save_string;
14646                 }
14647                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14648         }
14649         if (ndr_flags & NDR_BUFFERS) {
14650         }
14651         return NDR_ERR_SUCCESS;
14652 }
14653
14654 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14655 {
14656         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14657         ndr->depth++;
14658         ndr_print_string(ndr, "directory_name", r->directory_name);
14659         ndr->depth--;
14660 }
14661
14662 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14663 {
14664         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14665 }
14666
14667 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14668 {
14669         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14670         if (ndr_flags & NDR_SCALARS) {
14671                 int level = ndr_push_get_switch_value(ndr, r);
14672                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14673                 switch (level) {
14674                         case 1: {
14675                                 NDR_CHECK(ndr_push_align(ndr, 4));
14676                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14677                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14678                         break; }
14679
14680                         default: {
14681                                 NDR_CHECK(ndr_push_align(ndr, 4));
14682                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14683                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14684                         break; }
14685
14686                 }
14687         }
14688         if (ndr_flags & NDR_BUFFERS) {
14689                 int level = ndr_push_get_switch_value(ndr, r);
14690                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14691                 switch (level) {
14692                         case 1:
14693                         break;
14694
14695                         default:
14696                         break;
14697
14698                 }
14699         }
14700         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14701         return NDR_ERR_SUCCESS;
14702 }
14703
14704 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14705 {
14706         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14707         int level;
14708         level = ndr_pull_get_switch_value(ndr, r);
14709         if (ndr_flags & NDR_SCALARS) {
14710                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14711                 switch (level) {
14712                         case 1: {
14713                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14714                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14715                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14716                         break; }
14717
14718                         default: {
14719                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14720                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14721                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14722                         break; }
14723
14724                 }
14725         }
14726         if (ndr_flags & NDR_BUFFERS) {
14727                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14728                 switch (level) {
14729                         case 1:
14730                         break;
14731
14732                         default:
14733                         break;
14734
14735                 }
14736         }
14737         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14738         return NDR_ERR_SUCCESS;
14739 }
14740
14741 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14742 {
14743         int level;
14744         level = ndr_print_get_switch_value(ndr, r);
14745         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14746         switch (level) {
14747                 case 1:
14748                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14749                 break;
14750
14751                 default:
14752                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14753                 break;
14754
14755         }
14756 }
14757
14758 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14759 {
14760         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14761 }
14762
14763 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14764 {
14765         if (ndr_flags & NDR_SCALARS) {
14766                 NDR_CHECK(ndr_push_align(ndr, 5));
14767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14768                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14769                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14770                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14771         }
14772         if (ndr_flags & NDR_BUFFERS) {
14773                 if (r->document_name) {
14774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14777                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14778                 }
14779                 if (r->output_file) {
14780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14783                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14784                 }
14785                 if (r->datatype) {
14786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14787                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14789                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14790                 }
14791         }
14792         return NDR_ERR_SUCCESS;
14793 }
14794
14795 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14796 {
14797         uint32_t _ptr_document_name;
14798         TALLOC_CTX *_mem_save_document_name_0;
14799         uint32_t _ptr_output_file;
14800         TALLOC_CTX *_mem_save_output_file_0;
14801         uint32_t _ptr_datatype;
14802         TALLOC_CTX *_mem_save_datatype_0;
14803         if (ndr_flags & NDR_SCALARS) {
14804                 NDR_CHECK(ndr_pull_align(ndr, 5));
14805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14806                 if (_ptr_document_name) {
14807                         NDR_PULL_ALLOC(ndr, r->document_name);
14808                 } else {
14809                         r->document_name = NULL;
14810                 }
14811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14812                 if (_ptr_output_file) {
14813                         NDR_PULL_ALLOC(ndr, r->output_file);
14814                 } else {
14815                         r->output_file = NULL;
14816                 }
14817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14818                 if (_ptr_datatype) {
14819                         NDR_PULL_ALLOC(ndr, r->datatype);
14820                 } else {
14821                         r->datatype = NULL;
14822                 }
14823                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14824         }
14825         if (ndr_flags & NDR_BUFFERS) {
14826                 if (r->document_name) {
14827                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14828                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14829                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14830                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14831                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14832                                 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));
14833                         }
14834                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14835                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14837                 }
14838                 if (r->output_file) {
14839                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14840                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14842                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14843                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14844                                 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));
14845                         }
14846                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14847                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14849                 }
14850                 if (r->datatype) {
14851                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14852                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14853                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14854                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14855                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14856                                 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));
14857                         }
14858                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14859                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14861                 }
14862         }
14863         return NDR_ERR_SUCCESS;
14864 }
14865
14866 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14867 {
14868         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14869         ndr->depth++;
14870         ndr_print_ptr(ndr, "document_name", r->document_name);
14871         ndr->depth++;
14872         if (r->document_name) {
14873                 ndr_print_string(ndr, "document_name", r->document_name);
14874         }
14875         ndr->depth--;
14876         ndr_print_ptr(ndr, "output_file", r->output_file);
14877         ndr->depth++;
14878         if (r->output_file) {
14879                 ndr_print_string(ndr, "output_file", r->output_file);
14880         }
14881         ndr->depth--;
14882         ndr_print_ptr(ndr, "datatype", r->datatype);
14883         ndr->depth++;
14884         if (r->datatype) {
14885                 ndr_print_string(ndr, "datatype", r->datatype);
14886         }
14887         ndr->depth--;
14888         ndr->depth--;
14889 }
14890
14891 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14892 {
14893         if (ndr_flags & NDR_SCALARS) {
14894                 int level = ndr_push_get_switch_value(ndr, r);
14895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14896                 NDR_CHECK(ndr_push_union_align(ndr, 5));
14897                 switch (level) {
14898                         case 1: {
14899                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14900                         break; }
14901
14902                         case 2: {
14903                         break; }
14904
14905                         case 3: {
14906                         break; }
14907
14908                         default: {
14909                         break; }
14910
14911                 }
14912         }
14913         if (ndr_flags & NDR_BUFFERS) {
14914                 int level = ndr_push_get_switch_value(ndr, r);
14915                 switch (level) {
14916                         case 1:
14917                                 if (r->info1) {
14918                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14919                                 }
14920                         break;
14921
14922                         case 2:
14923                         break;
14924
14925                         case 3:
14926                         break;
14927
14928                         default:
14929                         break;
14930
14931                 }
14932         }
14933         return NDR_ERR_SUCCESS;
14934 }
14935
14936 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14937 {
14938         int level;
14939         uint32_t _level;
14940         TALLOC_CTX *_mem_save_info1_0;
14941         level = ndr_pull_get_switch_value(ndr, r);
14942         if (ndr_flags & NDR_SCALARS) {
14943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14944                 if (_level != level) {
14945                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
14946                 }
14947                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14948                 switch (level) {
14949                         case 1: {
14950                                 uint32_t _ptr_info1;
14951                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14952                                 if (_ptr_info1) {
14953                                         NDR_PULL_ALLOC(ndr, r->info1);
14954                                 } else {
14955                                         r->info1 = NULL;
14956                                 }
14957                         break; }
14958
14959                         case 2: {
14960                         break; }
14961
14962                         case 3: {
14963                         break; }
14964
14965                         default: {
14966                         break; }
14967
14968                 }
14969         }
14970         if (ndr_flags & NDR_BUFFERS) {
14971                 switch (level) {
14972                         case 1:
14973                                 if (r->info1) {
14974                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14975                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14976                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14977                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14978                                 }
14979                         break;
14980
14981                         case 2:
14982                         break;
14983
14984                         case 3:
14985                         break;
14986
14987                         default:
14988                         break;
14989
14990                 }
14991         }
14992         return NDR_ERR_SUCCESS;
14993 }
14994
14995 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14996 {
14997         int level;
14998         level = ndr_print_get_switch_value(ndr, r);
14999         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15000         switch (level) {
15001                 case 1:
15002                         ndr_print_ptr(ndr, "info1", r->info1);
15003                         ndr->depth++;
15004                         if (r->info1) {
15005                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15006                         }
15007                         ndr->depth--;
15008                 break;
15009
15010                 case 2:
15011                 break;
15012
15013                 case 3:
15014                 break;
15015
15016                 default:
15017                 break;
15018
15019         }
15020 }
15021
15022 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15023 {
15024         if (ndr_flags & NDR_SCALARS) {
15025                 NDR_CHECK(ndr_push_align(ndr, 4));
15026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15031                 {
15032                         uint32_t _flags_save_string = ndr->flags;
15033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15034                         {
15035                                 struct ndr_push *_ndr_extra_string;
15036                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15037                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15038                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15039                         }
15040                         ndr->flags = _flags_save_string;
15041                 }
15042                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15043         }
15044         if (ndr_flags & NDR_BUFFERS) {
15045         }
15046         return NDR_ERR_SUCCESS;
15047 }
15048
15049 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15050 {
15051         if (ndr_flags & NDR_SCALARS) {
15052                 NDR_CHECK(ndr_pull_align(ndr, 4));
15053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15058                 {
15059                         uint32_t _flags_save_string = ndr->flags;
15060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15061                         {
15062                                 struct ndr_pull *_ndr_extra_string;
15063                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15064                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15065                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15066                         }
15067                         ndr->flags = _flags_save_string;
15068                 }
15069                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15070         }
15071         if (ndr_flags & NDR_BUFFERS) {
15072         }
15073         return NDR_ERR_SUCCESS;
15074 }
15075
15076 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15077 {
15078         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15079         ndr->depth++;
15080         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);
15081         ndr_print_uint32(ndr, "major", r->major);
15082         ndr_print_uint32(ndr, "minor", r->minor);
15083         ndr_print_uint32(ndr, "build", r->build);
15084         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15085         ndr_print_string(ndr, "extra_string", r->extra_string);
15086         ndr->depth--;
15087 }
15088
15089 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15090 {
15091         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15092 }
15093
15094 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15095 {
15096         if (ndr_flags & NDR_SCALARS) {
15097                 NDR_CHECK(ndr_push_align(ndr, 4));
15098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15103                 {
15104                         uint32_t _flags_save_string = ndr->flags;
15105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15106                         {
15107                                 struct ndr_push *_ndr_extra_string;
15108                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15109                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15110                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15111                         }
15112                         ndr->flags = _flags_save_string;
15113                 }
15114                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15115                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15116                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15117                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15118                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15119                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15120         }
15121         if (ndr_flags & NDR_BUFFERS) {
15122         }
15123         return NDR_ERR_SUCCESS;
15124 }
15125
15126 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15127 {
15128         if (ndr_flags & NDR_SCALARS) {
15129                 NDR_CHECK(ndr_pull_align(ndr, 4));
15130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15135                 {
15136                         uint32_t _flags_save_string = ndr->flags;
15137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15138                         {
15139                                 struct ndr_pull *_ndr_extra_string;
15140                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15141                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15142                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15143                         }
15144                         ndr->flags = _flags_save_string;
15145                 }
15146                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15147                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15148                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15149                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15150                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15151                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15152         }
15153         if (ndr_flags & NDR_BUFFERS) {
15154         }
15155         return NDR_ERR_SUCCESS;
15156 }
15157
15158 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15159 {
15160         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15161         ndr->depth++;
15162         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);
15163         ndr_print_uint32(ndr, "major", r->major);
15164         ndr_print_uint32(ndr, "minor", r->minor);
15165         ndr_print_uint32(ndr, "build", r->build);
15166         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15167         ndr_print_string(ndr, "extra_string", r->extra_string);
15168         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15169         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15170         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15171         ndr_print_uint8(ndr, "product_type", r->product_type);
15172         ndr_print_uint8(ndr, "reserved", r->reserved);
15173         ndr->depth--;
15174 }
15175
15176 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15177 {
15178         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15179 }
15180
15181 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15182 {
15183         if (ndr_flags & NDR_SCALARS) {
15184                 int level = ndr_push_get_switch_value(ndr, r);
15185                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15186                 switch (level) {
15187                         case REG_NONE: {
15188                         break; }
15189
15190                         case REG_SZ: {
15191                                 {
15192                                         uint32_t _flags_save_string = ndr->flags;
15193                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15194                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15195                                         ndr->flags = _flags_save_string;
15196                                 }
15197                         break; }
15198
15199                         case REG_BINARY: {
15200                                 {
15201                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15202                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15203                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15204                                         ndr->flags = _flags_save_DATA_BLOB;
15205                                 }
15206                         break; }
15207
15208                         case REG_DWORD: {
15209                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15210                         break; }
15211
15212                         case REG_MULTI_SZ: {
15213                                 {
15214                                         uint32_t _flags_save_string_array = ndr->flags;
15215                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15216                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15217                                         ndr->flags = _flags_save_string_array;
15218                                 }
15219                         break; }
15220
15221                         default: {
15222                                 {
15223                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15224                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15225                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15226                                         ndr->flags = _flags_save_DATA_BLOB;
15227                                 }
15228                         break; }
15229
15230                 }
15231         }
15232         if (ndr_flags & NDR_BUFFERS) {
15233                 int level = ndr_push_get_switch_value(ndr, r);
15234                 switch (level) {
15235                         case REG_NONE:
15236                         break;
15237
15238                         case REG_SZ:
15239                         break;
15240
15241                         case REG_BINARY:
15242                         break;
15243
15244                         case REG_DWORD:
15245                         break;
15246
15247                         case REG_MULTI_SZ:
15248                         break;
15249
15250                         default:
15251                         break;
15252
15253                 }
15254         }
15255         return NDR_ERR_SUCCESS;
15256 }
15257
15258 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15259 {
15260         int level;
15261         level = ndr_pull_get_switch_value(ndr, r);
15262         if (ndr_flags & NDR_SCALARS) {
15263                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15264                 switch (level) {
15265                         case REG_NONE: {
15266                         break; }
15267
15268                         case REG_SZ: {
15269                                 {
15270                                         uint32_t _flags_save_string = ndr->flags;
15271                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15272                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15273                                         ndr->flags = _flags_save_string;
15274                                 }
15275                         break; }
15276
15277                         case REG_BINARY: {
15278                                 {
15279                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15280                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15281                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15282                                         ndr->flags = _flags_save_DATA_BLOB;
15283                                 }
15284                         break; }
15285
15286                         case REG_DWORD: {
15287                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15288                         break; }
15289
15290                         case REG_MULTI_SZ: {
15291                                 {
15292                                         uint32_t _flags_save_string_array = ndr->flags;
15293                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15294                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15295                                         ndr->flags = _flags_save_string_array;
15296                                 }
15297                         break; }
15298
15299                         default: {
15300                                 {
15301                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15302                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15303                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15304                                         ndr->flags = _flags_save_DATA_BLOB;
15305                                 }
15306                         break; }
15307
15308                 }
15309         }
15310         if (ndr_flags & NDR_BUFFERS) {
15311                 switch (level) {
15312                         case REG_NONE:
15313                         break;
15314
15315                         case REG_SZ:
15316                         break;
15317
15318                         case REG_BINARY:
15319                         break;
15320
15321                         case REG_DWORD:
15322                         break;
15323
15324                         case REG_MULTI_SZ:
15325                         break;
15326
15327                         default:
15328                         break;
15329
15330                 }
15331         }
15332         return NDR_ERR_SUCCESS;
15333 }
15334
15335 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15336 {
15337         int level;
15338         level = ndr_print_get_switch_value(ndr, r);
15339         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15340         switch (level) {
15341                 case REG_NONE:
15342                 break;
15343
15344                 case REG_SZ:
15345                         ndr_print_string(ndr, "string", r->string);
15346                 break;
15347
15348                 case REG_BINARY:
15349                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15350                 break;
15351
15352                 case REG_DWORD:
15353                         ndr_print_uint32(ndr, "value", r->value);
15354                 break;
15355
15356                 case REG_MULTI_SZ:
15357                         ndr_print_string_array(ndr, "string_array", r->string_array);
15358                 break;
15359
15360                 default:
15361                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15362                 break;
15363
15364         }
15365 }
15366
15367 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15368 {
15369         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
15370 }
15371
15372 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15373 {
15374         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15375         return NDR_ERR_SUCCESS;
15376 }
15377
15378 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15379 {
15380         uint32_t v;
15381         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15382         *r = v;
15383         return NDR_ERR_SUCCESS;
15384 }
15385
15386 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15387 {
15388         const char *val = NULL;
15389
15390         switch (r) {
15391                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15392                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15393                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15394         }
15395         ndr_print_enum(ndr, name, "ENUM", val, r);
15396 }
15397
15398 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15399 {
15400         if (ndr_flags & NDR_SCALARS) {
15401                 NDR_CHECK(ndr_push_align(ndr, 4));
15402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15404                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15405         }
15406         if (ndr_flags & NDR_BUFFERS) {
15407         }
15408         return NDR_ERR_SUCCESS;
15409 }
15410
15411 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15412 {
15413         if (ndr_flags & NDR_SCALARS) {
15414                 NDR_CHECK(ndr_pull_align(ndr, 4));
15415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15417                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15418         }
15419         if (ndr_flags & NDR_BUFFERS) {
15420         }
15421         return NDR_ERR_SUCCESS;
15422 }
15423
15424 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15425 {
15426         ndr_print_struct(ndr, name, "spoolss_FormSize");
15427         ndr->depth++;
15428         ndr_print_uint32(ndr, "width", r->width);
15429         ndr_print_uint32(ndr, "height", r->height);
15430         ndr->depth--;
15431 }
15432
15433 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15434 {
15435         if (ndr_flags & NDR_SCALARS) {
15436                 NDR_CHECK(ndr_push_align(ndr, 4));
15437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15441                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15442         }
15443         if (ndr_flags & NDR_BUFFERS) {
15444         }
15445         return NDR_ERR_SUCCESS;
15446 }
15447
15448 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15449 {
15450         if (ndr_flags & NDR_SCALARS) {
15451                 NDR_CHECK(ndr_pull_align(ndr, 4));
15452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15456                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15457         }
15458         if (ndr_flags & NDR_BUFFERS) {
15459         }
15460         return NDR_ERR_SUCCESS;
15461 }
15462
15463 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15464 {
15465         ndr_print_struct(ndr, name, "spoolss_FormArea");
15466         ndr->depth++;
15467         ndr_print_uint32(ndr, "left", r->left);
15468         ndr_print_uint32(ndr, "top", r->top);
15469         ndr_print_uint32(ndr, "right", r->right);
15470         ndr_print_uint32(ndr, "bottom", r->bottom);
15471         ndr->depth--;
15472 }
15473
15474 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15475 {
15476         if (ndr_flags & NDR_SCALARS) {
15477                 NDR_CHECK(ndr_push_align(ndr, 5));
15478                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15479                 {
15480                         uint32_t _flags_save_string = ndr->flags;
15481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15482                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15483                         ndr->flags = _flags_save_string;
15484                 }
15485                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15486                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15487                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15488         }
15489         if (ndr_flags & NDR_BUFFERS) {
15490                 {
15491                         uint32_t _flags_save_string = ndr->flags;
15492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15493                         if (r->form_name) {
15494                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15495                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15496                         }
15497                         ndr->flags = _flags_save_string;
15498                 }
15499         }
15500         return NDR_ERR_SUCCESS;
15501 }
15502
15503 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15504 {
15505         uint32_t _ptr_form_name;
15506         TALLOC_CTX *_mem_save_form_name_0;
15507         if (ndr_flags & NDR_SCALARS) {
15508                 NDR_CHECK(ndr_pull_align(ndr, 5));
15509                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15510                 {
15511                         uint32_t _flags_save_string = ndr->flags;
15512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15514                         if (_ptr_form_name) {
15515                                 NDR_PULL_ALLOC(ndr, r->form_name);
15516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15517                         } else {
15518                                 r->form_name = NULL;
15519                         }
15520                         ndr->flags = _flags_save_string;
15521                 }
15522                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15523                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15524                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15525         }
15526         if (ndr_flags & NDR_BUFFERS) {
15527                 {
15528                         uint32_t _flags_save_string = ndr->flags;
15529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15530                         if (r->form_name) {
15531                                 uint32_t _relative_save_offset;
15532                                 _relative_save_offset = ndr->offset;
15533                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15534                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15535                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15536                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15537                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15538                                 ndr->offset = _relative_save_offset;
15539                         }
15540                         ndr->flags = _flags_save_string;
15541                 }
15542         }
15543         return NDR_ERR_SUCCESS;
15544 }
15545
15546 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15547 {
15548         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15549         ndr->depth++;
15550         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15551         ndr_print_ptr(ndr, "form_name", r->form_name);
15552         ndr->depth++;
15553         if (r->form_name) {
15554                 ndr_print_string(ndr, "form_name", r->form_name);
15555         }
15556         ndr->depth--;
15557         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15558         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15559         ndr->depth--;
15560 }
15561
15562 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15563 {
15564         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15565 }
15566
15567 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15568 {
15569         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15570         return NDR_ERR_SUCCESS;
15571 }
15572
15573 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15574 {
15575         uint32_t v;
15576         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15577         *r = v;
15578         return NDR_ERR_SUCCESS;
15579 }
15580
15581 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15582 {
15583         ndr_print_uint32(ndr, name, r);
15584         ndr->depth++;
15585         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15586         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15587         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15588         ndr->depth--;
15589 }
15590
15591 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15592 {
15593         if (ndr_flags & NDR_SCALARS) {
15594                 NDR_CHECK(ndr_push_align(ndr, 5));
15595                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15596                 {
15597                         uint32_t _flags_save_string = ndr->flags;
15598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15600                         ndr->flags = _flags_save_string;
15601                 }
15602                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15603                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15604                 {
15605                         uint32_t _flags_save_string = ndr->flags;
15606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15607                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15608                         ndr->flags = _flags_save_string;
15609                 }
15610                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15611                 {
15612                         uint32_t _flags_save_string = ndr->flags;
15613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15614                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15615                         ndr->flags = _flags_save_string;
15616                 }
15617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15618                 {
15619                         uint32_t _flags_save_string = ndr->flags;
15620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15621                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15622                         ndr->flags = _flags_save_string;
15623                 }
15624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15625                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15626         }
15627         if (ndr_flags & NDR_BUFFERS) {
15628                 {
15629                         uint32_t _flags_save_string = ndr->flags;
15630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15631                         if (r->form_name) {
15632                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15633                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15634                         }
15635                         ndr->flags = _flags_save_string;
15636                 }
15637                 {
15638                         uint32_t _flags_save_string = ndr->flags;
15639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15640                         if (r->keyword) {
15641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15643                         }
15644                         ndr->flags = _flags_save_string;
15645                 }
15646                 {
15647                         uint32_t _flags_save_string = ndr->flags;
15648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15649                         if (r->mui_dll) {
15650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15652                         }
15653                         ndr->flags = _flags_save_string;
15654                 }
15655                 {
15656                         uint32_t _flags_save_string = ndr->flags;
15657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15658                         if (r->display_name) {
15659                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15661                         }
15662                         ndr->flags = _flags_save_string;
15663                 }
15664         }
15665         return NDR_ERR_SUCCESS;
15666 }
15667
15668 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15669 {
15670         uint32_t _ptr_form_name;
15671         TALLOC_CTX *_mem_save_form_name_0;
15672         uint32_t _ptr_keyword;
15673         TALLOC_CTX *_mem_save_keyword_0;
15674         uint32_t _ptr_mui_dll;
15675         TALLOC_CTX *_mem_save_mui_dll_0;
15676         uint32_t _ptr_display_name;
15677         TALLOC_CTX *_mem_save_display_name_0;
15678         if (ndr_flags & NDR_SCALARS) {
15679                 NDR_CHECK(ndr_pull_align(ndr, 5));
15680                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15681                 {
15682                         uint32_t _flags_save_string = ndr->flags;
15683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15685                         if (_ptr_form_name) {
15686                                 NDR_PULL_ALLOC(ndr, r->form_name);
15687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15688                         } else {
15689                                 r->form_name = NULL;
15690                         }
15691                         ndr->flags = _flags_save_string;
15692                 }
15693                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15694                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15695                 {
15696                         uint32_t _flags_save_string = ndr->flags;
15697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15699                         if (_ptr_keyword) {
15700                                 NDR_PULL_ALLOC(ndr, r->keyword);
15701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15702                         } else {
15703                                 r->keyword = NULL;
15704                         }
15705                         ndr->flags = _flags_save_string;
15706                 }
15707                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15708                 {
15709                         uint32_t _flags_save_string = ndr->flags;
15710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15712                         if (_ptr_mui_dll) {
15713                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15715                         } else {
15716                                 r->mui_dll = NULL;
15717                         }
15718                         ndr->flags = _flags_save_string;
15719                 }
15720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15721                 {
15722                         uint32_t _flags_save_string = ndr->flags;
15723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15724                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15725                         if (_ptr_display_name) {
15726                                 NDR_PULL_ALLOC(ndr, r->display_name);
15727                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15728                         } else {
15729                                 r->display_name = NULL;
15730                         }
15731                         ndr->flags = _flags_save_string;
15732                 }
15733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15734                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15735         }
15736         if (ndr_flags & NDR_BUFFERS) {
15737                 {
15738                         uint32_t _flags_save_string = ndr->flags;
15739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15740                         if (r->form_name) {
15741                                 uint32_t _relative_save_offset;
15742                                 _relative_save_offset = ndr->offset;
15743                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15744                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15745                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15746                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15747                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15748                                 ndr->offset = _relative_save_offset;
15749                         }
15750                         ndr->flags = _flags_save_string;
15751                 }
15752                 {
15753                         uint32_t _flags_save_string = ndr->flags;
15754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15755                         if (r->keyword) {
15756                                 uint32_t _relative_save_offset;
15757                                 _relative_save_offset = ndr->offset;
15758                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15759                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15760                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15761                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15762                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15763                                 ndr->offset = _relative_save_offset;
15764                         }
15765                         ndr->flags = _flags_save_string;
15766                 }
15767                 {
15768                         uint32_t _flags_save_string = ndr->flags;
15769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15770                         if (r->mui_dll) {
15771                                 uint32_t _relative_save_offset;
15772                                 _relative_save_offset = ndr->offset;
15773                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15774                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15775                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15776                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15777                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15778                                 ndr->offset = _relative_save_offset;
15779                         }
15780                         ndr->flags = _flags_save_string;
15781                 }
15782                 {
15783                         uint32_t _flags_save_string = ndr->flags;
15784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15785                         if (r->display_name) {
15786                                 uint32_t _relative_save_offset;
15787                                 _relative_save_offset = ndr->offset;
15788                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15789                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15790                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15791                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15792                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15793                                 ndr->offset = _relative_save_offset;
15794                         }
15795                         ndr->flags = _flags_save_string;
15796                 }
15797         }
15798         return NDR_ERR_SUCCESS;
15799 }
15800
15801 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15802 {
15803         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15804         ndr->depth++;
15805         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15806         ndr_print_ptr(ndr, "form_name", r->form_name);
15807         ndr->depth++;
15808         if (r->form_name) {
15809                 ndr_print_string(ndr, "form_name", r->form_name);
15810         }
15811         ndr->depth--;
15812         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15813         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15814         ndr_print_ptr(ndr, "keyword", r->keyword);
15815         ndr->depth++;
15816         if (r->keyword) {
15817                 ndr_print_string(ndr, "keyword", r->keyword);
15818         }
15819         ndr->depth--;
15820         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15821         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15822         ndr->depth++;
15823         if (r->mui_dll) {
15824                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15825         }
15826         ndr->depth--;
15827         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15828         ndr_print_ptr(ndr, "display_name", r->display_name);
15829         ndr->depth++;
15830         if (r->display_name) {
15831                 ndr_print_string(ndr, "display_name", r->display_name);
15832         }
15833         ndr->depth--;
15834         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15835         ndr->depth--;
15836 }
15837
15838 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15839 {
15840         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15841 }
15842
15843 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15844 {
15845         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15846         if (ndr_flags & NDR_SCALARS) {
15847                 int level = ndr_push_get_switch_value(ndr, r);
15848                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15849                 switch (level) {
15850                         case 1: {
15851                                 NDR_CHECK(ndr_push_align(ndr, 5));
15852                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15853                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15854                         break; }
15855
15856                         case 2: {
15857                                 NDR_CHECK(ndr_push_align(ndr, 5));
15858                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15859                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15860                         break; }
15861
15862                         default: {
15863                         break; }
15864
15865                 }
15866         }
15867         if (ndr_flags & NDR_BUFFERS) {
15868                 int level = ndr_push_get_switch_value(ndr, r);
15869                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15870                 switch (level) {
15871                         case 1:
15872                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15873                         break;
15874
15875                         case 2:
15876                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15877                         break;
15878
15879                         default:
15880                         break;
15881
15882                 }
15883         }
15884         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15885         return NDR_ERR_SUCCESS;
15886 }
15887
15888 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15889 {
15890         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15891         int level;
15892         level = ndr_pull_get_switch_value(ndr, r);
15893         if (ndr_flags & NDR_SCALARS) {
15894                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15895                 switch (level) {
15896                         case 1: {
15897                                 NDR_CHECK(ndr_pull_align(ndr, 5));
15898                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15899                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15900                         break; }
15901
15902                         case 2: {
15903                                 NDR_CHECK(ndr_pull_align(ndr, 5));
15904                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15905                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15906                         break; }
15907
15908                         default: {
15909                         break; }
15910
15911                 }
15912         }
15913         if (ndr_flags & NDR_BUFFERS) {
15914                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15915                 switch (level) {
15916                         case 1:
15917                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15918                         break;
15919
15920                         case 2:
15921                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15922                         break;
15923
15924                         default:
15925                         break;
15926
15927                 }
15928         }
15929         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15930         return NDR_ERR_SUCCESS;
15931 }
15932
15933 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15934 {
15935         int level;
15936         level = ndr_print_get_switch_value(ndr, r);
15937         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15938         switch (level) {
15939                 case 1:
15940                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15941                 break;
15942
15943                 case 2:
15944                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15945                 break;
15946
15947                 default:
15948                 break;
15949
15950         }
15951 }
15952
15953 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15954 {
15955         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15956 }
15957
15958 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15959 {
15960         if (ndr_flags & NDR_SCALARS) {
15961                 NDR_CHECK(ndr_push_align(ndr, 5));
15962                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15964                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15965                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15966                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15967         }
15968         if (ndr_flags & NDR_BUFFERS) {
15969                 if (r->form_name) {
15970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15973                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15974                 }
15975         }
15976         return NDR_ERR_SUCCESS;
15977 }
15978
15979 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15980 {
15981         uint32_t _ptr_form_name;
15982         TALLOC_CTX *_mem_save_form_name_0;
15983         if (ndr_flags & NDR_SCALARS) {
15984                 NDR_CHECK(ndr_pull_align(ndr, 5));
15985                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15987                 if (_ptr_form_name) {
15988                         NDR_PULL_ALLOC(ndr, r->form_name);
15989                 } else {
15990                         r->form_name = NULL;
15991                 }
15992                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15993                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15994                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15995         }
15996         if (ndr_flags & NDR_BUFFERS) {
15997                 if (r->form_name) {
15998                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15999                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16002                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16003                                 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));
16004                         }
16005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16008                 }
16009         }
16010         return NDR_ERR_SUCCESS;
16011 }
16012
16013 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16014 {
16015         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16016         ndr->depth++;
16017         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16018         ndr_print_ptr(ndr, "form_name", r->form_name);
16019         ndr->depth++;
16020         if (r->form_name) {
16021                 ndr_print_string(ndr, "form_name", r->form_name);
16022         }
16023         ndr->depth--;
16024         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16025         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16026         ndr->depth--;
16027 }
16028
16029 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16030 {
16031         if (ndr_flags & NDR_SCALARS) {
16032                 NDR_CHECK(ndr_push_align(ndr, 5));
16033                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16035                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16036                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16038                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16043                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16044         }
16045         if (ndr_flags & NDR_BUFFERS) {
16046                 if (r->form_name) {
16047                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16048                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16051                 }
16052                 if (r->keyword) {
16053                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16054                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16055                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16057                 }
16058                 if (r->mui_dll) {
16059                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16060                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16061                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16063                 }
16064                 if (r->display_name) {
16065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16069                 }
16070         }
16071         return NDR_ERR_SUCCESS;
16072 }
16073
16074 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16075 {
16076         uint32_t _ptr_form_name;
16077         TALLOC_CTX *_mem_save_form_name_0;
16078         uint32_t _ptr_keyword;
16079         TALLOC_CTX *_mem_save_keyword_0;
16080         uint32_t _ptr_mui_dll;
16081         TALLOC_CTX *_mem_save_mui_dll_0;
16082         uint32_t _ptr_display_name;
16083         TALLOC_CTX *_mem_save_display_name_0;
16084         if (ndr_flags & NDR_SCALARS) {
16085                 NDR_CHECK(ndr_pull_align(ndr, 5));
16086                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16088                 if (_ptr_form_name) {
16089                         NDR_PULL_ALLOC(ndr, r->form_name);
16090                 } else {
16091                         r->form_name = NULL;
16092                 }
16093                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16094                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16096                 if (_ptr_keyword) {
16097                         NDR_PULL_ALLOC(ndr, r->keyword);
16098                 } else {
16099                         r->keyword = NULL;
16100                 }
16101                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16102                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16103                 if (_ptr_mui_dll) {
16104                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16105                 } else {
16106                         r->mui_dll = NULL;
16107                 }
16108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16110                 if (_ptr_display_name) {
16111                         NDR_PULL_ALLOC(ndr, r->display_name);
16112                 } else {
16113                         r->display_name = NULL;
16114                 }
16115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16116                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16117         }
16118         if (ndr_flags & NDR_BUFFERS) {
16119                 if (r->form_name) {
16120                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16121                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16122                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16123                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16124                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16125                                 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));
16126                         }
16127                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16128                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16130                 }
16131                 if (r->keyword) {
16132                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16133                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16134                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16135                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16136                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16137                                 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));
16138                         }
16139                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16140                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16142                 }
16143                 if (r->mui_dll) {
16144                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16145                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16146                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16147                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16148                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16149                                 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));
16150                         }
16151                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16152                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16153                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16154                 }
16155                 if (r->display_name) {
16156                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16157                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16159                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16160                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16161                                 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));
16162                         }
16163                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16164                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16166                 }
16167         }
16168         return NDR_ERR_SUCCESS;
16169 }
16170
16171 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16172 {
16173         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16174         ndr->depth++;
16175         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16176         ndr_print_ptr(ndr, "form_name", r->form_name);
16177         ndr->depth++;
16178         if (r->form_name) {
16179                 ndr_print_string(ndr, "form_name", r->form_name);
16180         }
16181         ndr->depth--;
16182         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16183         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16184         ndr_print_ptr(ndr, "keyword", r->keyword);
16185         ndr->depth++;
16186         if (r->keyword) {
16187                 ndr_print_string(ndr, "keyword", r->keyword);
16188         }
16189         ndr->depth--;
16190         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16191         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16192         ndr->depth++;
16193         if (r->mui_dll) {
16194                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16195         }
16196         ndr->depth--;
16197         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16198         ndr_print_ptr(ndr, "display_name", r->display_name);
16199         ndr->depth++;
16200         if (r->display_name) {
16201                 ndr_print_string(ndr, "display_name", r->display_name);
16202         }
16203         ndr->depth--;
16204         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16205         ndr->depth--;
16206 }
16207
16208 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16209 {
16210         if (ndr_flags & NDR_SCALARS) {
16211                 int level = ndr_push_get_switch_value(ndr, r);
16212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16213                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16214                 switch (level) {
16215                         case 1: {
16216                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16217                         break; }
16218
16219                         case 2: {
16220                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16221                         break; }
16222
16223                         default:
16224                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16225                 }
16226         }
16227         if (ndr_flags & NDR_BUFFERS) {
16228                 int level = ndr_push_get_switch_value(ndr, r);
16229                 switch (level) {
16230                         case 1:
16231                                 if (r->info1) {
16232                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16233                                 }
16234                         break;
16235
16236                         case 2:
16237                                 if (r->info2) {
16238                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16239                                 }
16240                         break;
16241
16242                         default:
16243                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16244                 }
16245         }
16246         return NDR_ERR_SUCCESS;
16247 }
16248
16249 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16250 {
16251         int level;
16252         uint32_t _level;
16253         TALLOC_CTX *_mem_save_info1_0;
16254         TALLOC_CTX *_mem_save_info2_0;
16255         level = ndr_pull_get_switch_value(ndr, r);
16256         if (ndr_flags & NDR_SCALARS) {
16257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16258                 if (_level != level) {
16259                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16260                 }
16261                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16262                 switch (level) {
16263                         case 1: {
16264                                 uint32_t _ptr_info1;
16265                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16266                                 if (_ptr_info1) {
16267                                         NDR_PULL_ALLOC(ndr, r->info1);
16268                                 } else {
16269                                         r->info1 = NULL;
16270                                 }
16271                         break; }
16272
16273                         case 2: {
16274                                 uint32_t _ptr_info2;
16275                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16276                                 if (_ptr_info2) {
16277                                         NDR_PULL_ALLOC(ndr, r->info2);
16278                                 } else {
16279                                         r->info2 = NULL;
16280                                 }
16281                         break; }
16282
16283                         default:
16284                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16285                 }
16286         }
16287         if (ndr_flags & NDR_BUFFERS) {
16288                 switch (level) {
16289                         case 1:
16290                                 if (r->info1) {
16291                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16292                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16293                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16294                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16295                                 }
16296                         break;
16297
16298                         case 2:
16299                                 if (r->info2) {
16300                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16301                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16302                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16303                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16304                                 }
16305                         break;
16306
16307                         default:
16308                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16309                 }
16310         }
16311         return NDR_ERR_SUCCESS;
16312 }
16313
16314 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16315 {
16316         int level;
16317         level = ndr_print_get_switch_value(ndr, r);
16318         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16319         switch (level) {
16320                 case 1:
16321                         ndr_print_ptr(ndr, "info1", r->info1);
16322                         ndr->depth++;
16323                         if (r->info1) {
16324                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16325                         }
16326                         ndr->depth--;
16327                 break;
16328
16329                 case 2:
16330                         ndr_print_ptr(ndr, "info2", r->info2);
16331                         ndr->depth++;
16332                         if (r->info2) {
16333                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16334                         }
16335                         ndr->depth--;
16336                 break;
16337
16338                 default:
16339                         ndr_print_bad_level(ndr, name, level);
16340         }
16341 }
16342
16343 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16344 {
16345         if (ndr_flags & NDR_SCALARS) {
16346                 NDR_CHECK(ndr_push_align(ndr, 5));
16347                 {
16348                         uint32_t _flags_save_string = ndr->flags;
16349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16350                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16351                         ndr->flags = _flags_save_string;
16352                 }
16353                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16354         }
16355         if (ndr_flags & NDR_BUFFERS) {
16356                 {
16357                         uint32_t _flags_save_string = ndr->flags;
16358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16359                         if (r->port_name) {
16360                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16361                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16362                         }
16363                         ndr->flags = _flags_save_string;
16364                 }
16365         }
16366         return NDR_ERR_SUCCESS;
16367 }
16368
16369 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16370 {
16371         uint32_t _ptr_port_name;
16372         TALLOC_CTX *_mem_save_port_name_0;
16373         if (ndr_flags & NDR_SCALARS) {
16374                 NDR_CHECK(ndr_pull_align(ndr, 5));
16375                 {
16376                         uint32_t _flags_save_string = ndr->flags;
16377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16378                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16379                         if (_ptr_port_name) {
16380                                 NDR_PULL_ALLOC(ndr, r->port_name);
16381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16382                         } else {
16383                                 r->port_name = NULL;
16384                         }
16385                         ndr->flags = _flags_save_string;
16386                 }
16387                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16388         }
16389         if (ndr_flags & NDR_BUFFERS) {
16390                 {
16391                         uint32_t _flags_save_string = ndr->flags;
16392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16393                         if (r->port_name) {
16394                                 uint32_t _relative_save_offset;
16395                                 _relative_save_offset = ndr->offset;
16396                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16397                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16398                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16399                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16400                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16401                                 ndr->offset = _relative_save_offset;
16402                         }
16403                         ndr->flags = _flags_save_string;
16404                 }
16405         }
16406         return NDR_ERR_SUCCESS;
16407 }
16408
16409 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16410 {
16411         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16412         ndr->depth++;
16413         ndr_print_ptr(ndr, "port_name", r->port_name);
16414         ndr->depth++;
16415         if (r->port_name) {
16416                 ndr_print_string(ndr, "port_name", r->port_name);
16417         }
16418         ndr->depth--;
16419         ndr->depth--;
16420 }
16421
16422 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16423 {
16424         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16425 }
16426
16427 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16428 {
16429         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16430         return NDR_ERR_SUCCESS;
16431 }
16432
16433 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16434 {
16435         uint32_t v;
16436         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16437         *r = v;
16438         return NDR_ERR_SUCCESS;
16439 }
16440
16441 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16442 {
16443         ndr_print_uint32(ndr, name, r);
16444         ndr->depth++;
16445         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16446         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16449         ndr->depth--;
16450 }
16451
16452 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16453 {
16454         if (ndr_flags & NDR_SCALARS) {
16455                 NDR_CHECK(ndr_push_align(ndr, 5));
16456                 {
16457                         uint32_t _flags_save_string = ndr->flags;
16458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16459                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16460                         ndr->flags = _flags_save_string;
16461                 }
16462                 {
16463                         uint32_t _flags_save_string = ndr->flags;
16464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16465                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16466                         ndr->flags = _flags_save_string;
16467                 }
16468                 {
16469                         uint32_t _flags_save_string = ndr->flags;
16470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16471                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16472                         ndr->flags = _flags_save_string;
16473                 }
16474                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16476                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16477         }
16478         if (ndr_flags & NDR_BUFFERS) {
16479                 {
16480                         uint32_t _flags_save_string = ndr->flags;
16481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16482                         if (r->port_name) {
16483                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16484                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16485                         }
16486                         ndr->flags = _flags_save_string;
16487                 }
16488                 {
16489                         uint32_t _flags_save_string = ndr->flags;
16490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16491                         if (r->monitor_name) {
16492                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16493                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16494                         }
16495                         ndr->flags = _flags_save_string;
16496                 }
16497                 {
16498                         uint32_t _flags_save_string = ndr->flags;
16499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16500                         if (r->description) {
16501                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
16502                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16503                         }
16504                         ndr->flags = _flags_save_string;
16505                 }
16506         }
16507         return NDR_ERR_SUCCESS;
16508 }
16509
16510 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16511 {
16512         uint32_t _ptr_port_name;
16513         TALLOC_CTX *_mem_save_port_name_0;
16514         uint32_t _ptr_monitor_name;
16515         TALLOC_CTX *_mem_save_monitor_name_0;
16516         uint32_t _ptr_description;
16517         TALLOC_CTX *_mem_save_description_0;
16518         if (ndr_flags & NDR_SCALARS) {
16519                 NDR_CHECK(ndr_pull_align(ndr, 5));
16520                 {
16521                         uint32_t _flags_save_string = ndr->flags;
16522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16524                         if (_ptr_port_name) {
16525                                 NDR_PULL_ALLOC(ndr, r->port_name);
16526                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16527                         } else {
16528                                 r->port_name = NULL;
16529                         }
16530                         ndr->flags = _flags_save_string;
16531                 }
16532                 {
16533                         uint32_t _flags_save_string = ndr->flags;
16534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16535                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16536                         if (_ptr_monitor_name) {
16537                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16538                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16539                         } else {
16540                                 r->monitor_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16548                         if (_ptr_description) {
16549                                 NDR_PULL_ALLOC(ndr, r->description);
16550                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16551                         } else {
16552                                 r->description = NULL;
16553                         }
16554                         ndr->flags = _flags_save_string;
16555                 }
16556                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16558                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16559         }
16560         if (ndr_flags & NDR_BUFFERS) {
16561                 {
16562                         uint32_t _flags_save_string = ndr->flags;
16563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16564                         if (r->port_name) {
16565                                 uint32_t _relative_save_offset;
16566                                 _relative_save_offset = ndr->offset;
16567                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16568                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16569                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16570                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16571                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16572                                 ndr->offset = _relative_save_offset;
16573                         }
16574                         ndr->flags = _flags_save_string;
16575                 }
16576                 {
16577                         uint32_t _flags_save_string = ndr->flags;
16578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16579                         if (r->monitor_name) {
16580                                 uint32_t _relative_save_offset;
16581                                 _relative_save_offset = ndr->offset;
16582                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16583                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16584                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16585                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16586                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16587                                 ndr->offset = _relative_save_offset;
16588                         }
16589                         ndr->flags = _flags_save_string;
16590                 }
16591                 {
16592                         uint32_t _flags_save_string = ndr->flags;
16593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16594                         if (r->description) {
16595                                 uint32_t _relative_save_offset;
16596                                 _relative_save_offset = ndr->offset;
16597                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
16598                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
16599                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
16600                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
16601                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
16602                                 ndr->offset = _relative_save_offset;
16603                         }
16604                         ndr->flags = _flags_save_string;
16605                 }
16606         }
16607         return NDR_ERR_SUCCESS;
16608 }
16609
16610 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
16611 {
16612         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
16613         ndr->depth++;
16614         ndr_print_ptr(ndr, "port_name", r->port_name);
16615         ndr->depth++;
16616         if (r->port_name) {
16617                 ndr_print_string(ndr, "port_name", r->port_name);
16618         }
16619         ndr->depth--;
16620         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16621         ndr->depth++;
16622         if (r->monitor_name) {
16623                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16624         }
16625         ndr->depth--;
16626         ndr_print_ptr(ndr, "description", r->description);
16627         ndr->depth++;
16628         if (r->description) {
16629                 ndr_print_string(ndr, "description", r->description);
16630         }
16631         ndr->depth--;
16632         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
16633         ndr_print_uint32(ndr, "reserved", r->reserved);
16634         ndr->depth--;
16635 }
16636
16637 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16638 {
16639         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
16640 }
16641
16642 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16643 {
16644         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16645         return NDR_ERR_SUCCESS;
16646 }
16647
16648 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16649 {
16650         uint32_t v;
16651         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16652         *r = v;
16653         return NDR_ERR_SUCCESS;
16654 }
16655
16656 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16657 {
16658         const char *val = NULL;
16659
16660         switch (r) {
16661                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16662                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16663                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16664                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16665                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16666                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16667                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16668                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16669                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16670                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16671                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16672                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16673                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16674         }
16675         ndr_print_enum(ndr, name, "ENUM", val, r);
16676 }
16677
16678 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16679 {
16680         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16681         return NDR_ERR_SUCCESS;
16682 }
16683
16684 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16685 {
16686         uint32_t v;
16687         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16688         *r = v;
16689         return NDR_ERR_SUCCESS;
16690 }
16691
16692 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16693 {
16694         const char *val = NULL;
16695
16696         switch (r) {
16697                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16698                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16699                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16700         }
16701         ndr_print_enum(ndr, name, "ENUM", val, r);
16702 }
16703
16704 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16705 {
16706         if (ndr_flags & NDR_SCALARS) {
16707                 NDR_CHECK(ndr_push_align(ndr, 5));
16708                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16709                 {
16710                         uint32_t _flags_save_string = ndr->flags;
16711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16712                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16713                         ndr->flags = _flags_save_string;
16714                 }
16715                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16716                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16717         }
16718         if (ndr_flags & NDR_BUFFERS) {
16719                 {
16720                         uint32_t _flags_save_string = ndr->flags;
16721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16722                         if (r->status_string) {
16723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16725                         }
16726                         ndr->flags = _flags_save_string;
16727                 }
16728         }
16729         return NDR_ERR_SUCCESS;
16730 }
16731
16732 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16733 {
16734         uint32_t _ptr_status_string;
16735         TALLOC_CTX *_mem_save_status_string_0;
16736         if (ndr_flags & NDR_SCALARS) {
16737                 NDR_CHECK(ndr_pull_align(ndr, 5));
16738                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16739                 {
16740                         uint32_t _flags_save_string = ndr->flags;
16741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16742                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16743                         if (_ptr_status_string) {
16744                                 NDR_PULL_ALLOC(ndr, r->status_string);
16745                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16746                         } else {
16747                                 r->status_string = NULL;
16748                         }
16749                         ndr->flags = _flags_save_string;
16750                 }
16751                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16752                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16753         }
16754         if (ndr_flags & NDR_BUFFERS) {
16755                 {
16756                         uint32_t _flags_save_string = ndr->flags;
16757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16758                         if (r->status_string) {
16759                                 uint32_t _relative_save_offset;
16760                                 _relative_save_offset = ndr->offset;
16761                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16762                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16763                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16764                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16765                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16766                                 ndr->offset = _relative_save_offset;
16767                         }
16768                         ndr->flags = _flags_save_string;
16769                 }
16770         }
16771         return NDR_ERR_SUCCESS;
16772 }
16773
16774 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16775 {
16776         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16777         ndr->depth++;
16778         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16779         ndr_print_ptr(ndr, "status_string", r->status_string);
16780         ndr->depth++;
16781         if (r->status_string) {
16782                 ndr_print_string(ndr, "status_string", r->status_string);
16783         }
16784         ndr->depth--;
16785         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16786         ndr->depth--;
16787 }
16788
16789 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16790 {
16791         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16792 }
16793
16794 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16795 {
16796         if (ndr_flags & NDR_SCALARS) {
16797                 NDR_CHECK(ndr_push_align(ndr, 5));
16798                 {
16799                         uint32_t _flags_save_string = ndr->flags;
16800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16801                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16802                         ndr->flags = _flags_save_string;
16803                 }
16804                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16805                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16806         }
16807         if (ndr_flags & NDR_BUFFERS) {
16808                 {
16809                         uint32_t _flags_save_string = ndr->flags;
16810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16811                         if (r->port_name) {
16812                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16813                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16814                         }
16815                         ndr->flags = _flags_save_string;
16816                 }
16817         }
16818         return NDR_ERR_SUCCESS;
16819 }
16820
16821 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16822 {
16823         uint32_t _ptr_port_name;
16824         TALLOC_CTX *_mem_save_port_name_0;
16825         if (ndr_flags & NDR_SCALARS) {
16826                 NDR_CHECK(ndr_pull_align(ndr, 5));
16827                 {
16828                         uint32_t _flags_save_string = ndr->flags;
16829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16830                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16831                         if (_ptr_port_name) {
16832                                 NDR_PULL_ALLOC(ndr, r->port_name);
16833                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16834                         } else {
16835                                 r->port_name = NULL;
16836                         }
16837                         ndr->flags = _flags_save_string;
16838                 }
16839                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16840                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16841         }
16842         if (ndr_flags & NDR_BUFFERS) {
16843                 {
16844                         uint32_t _flags_save_string = ndr->flags;
16845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16846                         if (r->port_name) {
16847                                 uint32_t _relative_save_offset;
16848                                 _relative_save_offset = ndr->offset;
16849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16850                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16851                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16854                                 ndr->offset = _relative_save_offset;
16855                         }
16856                         ndr->flags = _flags_save_string;
16857                 }
16858         }
16859         return NDR_ERR_SUCCESS;
16860 }
16861
16862 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16863 {
16864         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16865         ndr->depth++;
16866         ndr_print_ptr(ndr, "port_name", r->port_name);
16867         ndr->depth++;
16868         if (r->port_name) {
16869                 ndr_print_string(ndr, "port_name", r->port_name);
16870         }
16871         ndr->depth--;
16872         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16873         ndr->depth--;
16874 }
16875
16876 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16877 {
16878         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16879 }
16880
16881 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16882 {
16883         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16884         if (ndr_flags & NDR_SCALARS) {
16885                 int level = ndr_push_get_switch_value(ndr, r);
16886                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16887                 switch (level) {
16888                         case 1: {
16889                                 NDR_CHECK(ndr_push_align(ndr, 5));
16890                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16891                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16892                         break; }
16893
16894                         case 2: {
16895                                 NDR_CHECK(ndr_push_align(ndr, 5));
16896                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16897                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16898                         break; }
16899
16900                         case 3: {
16901                                 NDR_CHECK(ndr_push_align(ndr, 5));
16902                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16903                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16904                         break; }
16905
16906                         case 0xff: {
16907                                 NDR_CHECK(ndr_push_align(ndr, 5));
16908                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16909                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16910                         break; }
16911
16912                         default: {
16913                         break; }
16914
16915                 }
16916         }
16917         if (ndr_flags & NDR_BUFFERS) {
16918                 int level = ndr_push_get_switch_value(ndr, r);
16919                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16920                 switch (level) {
16921                         case 1:
16922                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16923                         break;
16924
16925                         case 2:
16926                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16927                         break;
16928
16929                         case 3:
16930                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16931                         break;
16932
16933                         case 0xff:
16934                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16935                         break;
16936
16937                         default:
16938                         break;
16939
16940                 }
16941         }
16942         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16943         return NDR_ERR_SUCCESS;
16944 }
16945
16946 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16947 {
16948         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16949         int level;
16950         level = ndr_pull_get_switch_value(ndr, r);
16951         if (ndr_flags & NDR_SCALARS) {
16952                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16953                 switch (level) {
16954                         case 1: {
16955                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16956                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16957                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16958                         break; }
16959
16960                         case 2: {
16961                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16962                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16963                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16964                         break; }
16965
16966                         case 3: {
16967                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16968                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16969                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16970                         break; }
16971
16972                         case 0xff: {
16973                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16974                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16975                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16976                         break; }
16977
16978                         default: {
16979                         break; }
16980
16981                 }
16982         }
16983         if (ndr_flags & NDR_BUFFERS) {
16984                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16985                 switch (level) {
16986                         case 1:
16987                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16988                         break;
16989
16990                         case 2:
16991                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16992                         break;
16993
16994                         case 3:
16995                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16996                         break;
16997
16998                         case 0xff:
16999                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17000                         break;
17001
17002                         default:
17003                         break;
17004
17005                 }
17006         }
17007         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17008         return NDR_ERR_SUCCESS;
17009 }
17010
17011 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17012 {
17013         int level;
17014         level = ndr_print_get_switch_value(ndr, r);
17015         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17016         switch (level) {
17017                 case 1:
17018                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17019                 break;
17020
17021                 case 2:
17022                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17023                 break;
17024
17025                 case 3:
17026                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17027                 break;
17028
17029                 case 0xff:
17030                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17031                 break;
17032
17033                 default:
17034                 break;
17035
17036         }
17037 }
17038
17039 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17040 {
17041         if (ndr_flags & NDR_SCALARS) {
17042                 NDR_CHECK(ndr_push_align(ndr, 5));
17043                 {
17044                         uint32_t _flags_save_string = ndr->flags;
17045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17046                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17047                         ndr->flags = _flags_save_string;
17048                 }
17049                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17050         }
17051         if (ndr_flags & NDR_BUFFERS) {
17052                 {
17053                         uint32_t _flags_save_string = ndr->flags;
17054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17055                         if (r->monitor_name) {
17056                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17057                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17058                         }
17059                         ndr->flags = _flags_save_string;
17060                 }
17061         }
17062         return NDR_ERR_SUCCESS;
17063 }
17064
17065 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17066 {
17067         uint32_t _ptr_monitor_name;
17068         TALLOC_CTX *_mem_save_monitor_name_0;
17069         if (ndr_flags & NDR_SCALARS) {
17070                 NDR_CHECK(ndr_pull_align(ndr, 5));
17071                 {
17072                         uint32_t _flags_save_string = ndr->flags;
17073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17074                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17075                         if (_ptr_monitor_name) {
17076                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17077                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17078                         } else {
17079                                 r->monitor_name = NULL;
17080                         }
17081                         ndr->flags = _flags_save_string;
17082                 }
17083                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17084         }
17085         if (ndr_flags & NDR_BUFFERS) {
17086                 {
17087                         uint32_t _flags_save_string = ndr->flags;
17088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17089                         if (r->monitor_name) {
17090                                 uint32_t _relative_save_offset;
17091                                 _relative_save_offset = ndr->offset;
17092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17093                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17094                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17095                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17097                                 ndr->offset = _relative_save_offset;
17098                         }
17099                         ndr->flags = _flags_save_string;
17100                 }
17101         }
17102         return NDR_ERR_SUCCESS;
17103 }
17104
17105 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17106 {
17107         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17108         ndr->depth++;
17109         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17110         ndr->depth++;
17111         if (r->monitor_name) {
17112                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17113         }
17114         ndr->depth--;
17115         ndr->depth--;
17116 }
17117
17118 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17119 {
17120         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17121 }
17122
17123 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17124 {
17125         if (ndr_flags & NDR_SCALARS) {
17126                 NDR_CHECK(ndr_push_align(ndr, 5));
17127                 {
17128                         uint32_t _flags_save_string = ndr->flags;
17129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17130                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17131                         ndr->flags = _flags_save_string;
17132                 }
17133                 {
17134                         uint32_t _flags_save_string = ndr->flags;
17135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17136                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17137                         ndr->flags = _flags_save_string;
17138                 }
17139                 {
17140                         uint32_t _flags_save_string = ndr->flags;
17141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17142                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17143                         ndr->flags = _flags_save_string;
17144                 }
17145                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17146         }
17147         if (ndr_flags & NDR_BUFFERS) {
17148                 {
17149                         uint32_t _flags_save_string = ndr->flags;
17150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17151                         if (r->monitor_name) {
17152                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17153                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17154                         }
17155                         ndr->flags = _flags_save_string;
17156                 }
17157                 {
17158                         uint32_t _flags_save_string = ndr->flags;
17159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17160                         if (r->environment) {
17161                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17162                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17163                         }
17164                         ndr->flags = _flags_save_string;
17165                 }
17166                 {
17167                         uint32_t _flags_save_string = ndr->flags;
17168                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17169                         if (r->dll_name) {
17170                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17171                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17172                         }
17173                         ndr->flags = _flags_save_string;
17174                 }
17175         }
17176         return NDR_ERR_SUCCESS;
17177 }
17178
17179 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17180 {
17181         uint32_t _ptr_monitor_name;
17182         TALLOC_CTX *_mem_save_monitor_name_0;
17183         uint32_t _ptr_environment;
17184         TALLOC_CTX *_mem_save_environment_0;
17185         uint32_t _ptr_dll_name;
17186         TALLOC_CTX *_mem_save_dll_name_0;
17187         if (ndr_flags & NDR_SCALARS) {
17188                 NDR_CHECK(ndr_pull_align(ndr, 5));
17189                 {
17190                         uint32_t _flags_save_string = ndr->flags;
17191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17193                         if (_ptr_monitor_name) {
17194                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17196                         } else {
17197                                 r->monitor_name = NULL;
17198                         }
17199                         ndr->flags = _flags_save_string;
17200                 }
17201                 {
17202                         uint32_t _flags_save_string = ndr->flags;
17203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17205                         if (_ptr_environment) {
17206                                 NDR_PULL_ALLOC(ndr, r->environment);
17207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17208                         } else {
17209                                 r->environment = NULL;
17210                         }
17211                         ndr->flags = _flags_save_string;
17212                 }
17213                 {
17214                         uint32_t _flags_save_string = ndr->flags;
17215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17217                         if (_ptr_dll_name) {
17218                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17220                         } else {
17221                                 r->dll_name = NULL;
17222                         }
17223                         ndr->flags = _flags_save_string;
17224                 }
17225                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17226         }
17227         if (ndr_flags & NDR_BUFFERS) {
17228                 {
17229                         uint32_t _flags_save_string = ndr->flags;
17230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17231                         if (r->monitor_name) {
17232                                 uint32_t _relative_save_offset;
17233                                 _relative_save_offset = ndr->offset;
17234                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17235                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17236                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17237                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17238                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17239                                 ndr->offset = _relative_save_offset;
17240                         }
17241                         ndr->flags = _flags_save_string;
17242                 }
17243                 {
17244                         uint32_t _flags_save_string = ndr->flags;
17245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17246                         if (r->environment) {
17247                                 uint32_t _relative_save_offset;
17248                                 _relative_save_offset = ndr->offset;
17249                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17250                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17251                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17252                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17253                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17254                                 ndr->offset = _relative_save_offset;
17255                         }
17256                         ndr->flags = _flags_save_string;
17257                 }
17258                 {
17259                         uint32_t _flags_save_string = ndr->flags;
17260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17261                         if (r->dll_name) {
17262                                 uint32_t _relative_save_offset;
17263                                 _relative_save_offset = ndr->offset;
17264                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17265                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17266                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17267                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17268                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17269                                 ndr->offset = _relative_save_offset;
17270                         }
17271                         ndr->flags = _flags_save_string;
17272                 }
17273         }
17274         return NDR_ERR_SUCCESS;
17275 }
17276
17277 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17278 {
17279         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17280         ndr->depth++;
17281         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17282         ndr->depth++;
17283         if (r->monitor_name) {
17284                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17285         }
17286         ndr->depth--;
17287         ndr_print_ptr(ndr, "environment", r->environment);
17288         ndr->depth++;
17289         if (r->environment) {
17290                 ndr_print_string(ndr, "environment", r->environment);
17291         }
17292         ndr->depth--;
17293         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17294         ndr->depth++;
17295         if (r->dll_name) {
17296                 ndr_print_string(ndr, "dll_name", r->dll_name);
17297         }
17298         ndr->depth--;
17299         ndr->depth--;
17300 }
17301
17302 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17303 {
17304         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17305 }
17306
17307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17308 {
17309         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17310         if (ndr_flags & NDR_SCALARS) {
17311                 int level = ndr_push_get_switch_value(ndr, r);
17312                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17313                 switch (level) {
17314                         case 1: {
17315                                 NDR_CHECK(ndr_push_align(ndr, 5));
17316                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17317                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17318                         break; }
17319
17320                         case 2: {
17321                                 NDR_CHECK(ndr_push_align(ndr, 5));
17322                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17323                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17324                         break; }
17325
17326                         default: {
17327                         break; }
17328
17329                 }
17330         }
17331         if (ndr_flags & NDR_BUFFERS) {
17332                 int level = ndr_push_get_switch_value(ndr, r);
17333                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17334                 switch (level) {
17335                         case 1:
17336                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17337                         break;
17338
17339                         case 2:
17340                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17341                         break;
17342
17343                         default:
17344                         break;
17345
17346                 }
17347         }
17348         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17349         return NDR_ERR_SUCCESS;
17350 }
17351
17352 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17353 {
17354         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17355         int level;
17356         level = ndr_pull_get_switch_value(ndr, r);
17357         if (ndr_flags & NDR_SCALARS) {
17358                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17359                 switch (level) {
17360                         case 1: {
17361                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17362                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17363                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17364                         break; }
17365
17366                         case 2: {
17367                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17368                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17369                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17370                         break; }
17371
17372                         default: {
17373                         break; }
17374
17375                 }
17376         }
17377         if (ndr_flags & NDR_BUFFERS) {
17378                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17379                 switch (level) {
17380                         case 1:
17381                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17382                         break;
17383
17384                         case 2:
17385                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17386                         break;
17387
17388                         default:
17389                         break;
17390
17391                 }
17392         }
17393         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17394         return NDR_ERR_SUCCESS;
17395 }
17396
17397 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17398 {
17399         int level;
17400         level = ndr_print_get_switch_value(ndr, r);
17401         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17402         switch (level) {
17403                 case 1:
17404                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17405                 break;
17406
17407                 case 2:
17408                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17409                 break;
17410
17411                 default:
17412                 break;
17413
17414         }
17415 }
17416
17417 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17418 {
17419         if (ndr_flags & NDR_SCALARS) {
17420                 NDR_CHECK(ndr_push_align(ndr, 5));
17421                 {
17422                         uint32_t _flags_save_string = ndr->flags;
17423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17424                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17425                         ndr->flags = _flags_save_string;
17426                 }
17427                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17428         }
17429         if (ndr_flags & NDR_BUFFERS) {
17430                 {
17431                         uint32_t _flags_save_string = ndr->flags;
17432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17433                         if (r->name_array) {
17434                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
17435                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17436                         }
17437                         ndr->flags = _flags_save_string;
17438                 }
17439         }
17440         return NDR_ERR_SUCCESS;
17441 }
17442
17443 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17444 {
17445         uint32_t _ptr_name_array;
17446         TALLOC_CTX *_mem_save_name_array_0;
17447         if (ndr_flags & NDR_SCALARS) {
17448                 NDR_CHECK(ndr_pull_align(ndr, 5));
17449                 {
17450                         uint32_t _flags_save_string = ndr->flags;
17451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17452                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17453                         if (_ptr_name_array) {
17454                                 NDR_PULL_ALLOC(ndr, r->name_array);
17455                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17456                         } else {
17457                                 r->name_array = NULL;
17458                         }
17459                         ndr->flags = _flags_save_string;
17460                 }
17461                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17462         }
17463         if (ndr_flags & NDR_BUFFERS) {
17464                 {
17465                         uint32_t _flags_save_string = ndr->flags;
17466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17467                         if (r->name_array) {
17468                                 uint32_t _relative_save_offset;
17469                                 _relative_save_offset = ndr->offset;
17470                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17471                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17472                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17473                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17474                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17475                                 ndr->offset = _relative_save_offset;
17476                         }
17477                         ndr->flags = _flags_save_string;
17478                 }
17479         }
17480         return NDR_ERR_SUCCESS;
17481 }
17482
17483 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17484 {
17485         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17486         ndr->depth++;
17487         ndr_print_ptr(ndr, "name_array", r->name_array);
17488         ndr->depth++;
17489         if (r->name_array) {
17490                 ndr_print_string(ndr, "name_array", r->name_array);
17491         }
17492         ndr->depth--;
17493         ndr->depth--;
17494 }
17495
17496 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17497 {
17498         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17499 }
17500
17501 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17502 {
17503         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17504         if (ndr_flags & NDR_SCALARS) {
17505                 int level = ndr_push_get_switch_value(ndr, r);
17506                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17507                 switch (level) {
17508                         case 1: {
17509                                 NDR_CHECK(ndr_push_align(ndr, 5));
17510                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17511                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17512                         break; }
17513
17514                         default: {
17515                         break; }
17516
17517                 }
17518         }
17519         if (ndr_flags & NDR_BUFFERS) {
17520                 int level = ndr_push_get_switch_value(ndr, r);
17521                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17522                 switch (level) {
17523                         case 1:
17524                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17525                         break;
17526
17527                         default:
17528                         break;
17529
17530                 }
17531         }
17532         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17533         return NDR_ERR_SUCCESS;
17534 }
17535
17536 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17537 {
17538         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17539         int level;
17540         level = ndr_pull_get_switch_value(ndr, r);
17541         if (ndr_flags & NDR_SCALARS) {
17542                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17543                 switch (level) {
17544                         case 1: {
17545                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17546                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17547                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17548                         break; }
17549
17550                         default: {
17551                         break; }
17552
17553                 }
17554         }
17555         if (ndr_flags & NDR_BUFFERS) {
17556                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17557                 switch (level) {
17558                         case 1:
17559                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17560                         break;
17561
17562                         default:
17563                         break;
17564
17565                 }
17566         }
17567         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17568         return NDR_ERR_SUCCESS;
17569 }
17570
17571 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
17572 {
17573         int level;
17574         level = ndr_print_get_switch_value(ndr, r);
17575         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
17576         switch (level) {
17577                 case 1:
17578                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
17579                 break;
17580
17581                 default:
17582                 break;
17583
17584         }
17585 }
17586
17587 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17588 {
17589         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17590         return NDR_ERR_SUCCESS;
17591 }
17592
17593 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17594 {
17595         uint32_t v;
17596         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17597         *r = v;
17598         return NDR_ERR_SUCCESS;
17599 }
17600
17601 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17602 {
17603         ndr_print_uint32(ndr, name, r);
17604         ndr->depth++;
17605         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
17606         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
17607         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
17608         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
17609         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
17610         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
17611         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
17612         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
17613         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
17614         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
17615         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
17616         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
17617         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
17618         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
17619         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
17620         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
17621         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
17622         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
17623         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
17624         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
17625         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
17626         ndr->depth--;
17627 }
17628
17629 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
17630 {
17631         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
17632         return NDR_ERR_SUCCESS;
17633 }
17634
17635 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
17636 {
17637         uint16_t v;
17638         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
17639         *r = v;
17640         return NDR_ERR_SUCCESS;
17641 }
17642
17643 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
17644 {
17645         const char *val = NULL;
17646
17647         switch (r) {
17648                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
17649                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
17650                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
17651                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
17652                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
17653                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
17654                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17655                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
17656                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
17657                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
17658                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
17659                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
17660                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17661                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17662                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17663                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17664                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17665                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17666                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17667                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17668                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17669                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17670                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17671                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17672         }
17673         ndr_print_enum(ndr, name, "ENUM", val, r);
17674 }
17675
17676 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17677 {
17678         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
17679         return NDR_ERR_SUCCESS;
17680 }
17681
17682 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17683 {
17684         uint16_t v;
17685         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
17686         *r = v;
17687         return NDR_ERR_SUCCESS;
17688 }
17689
17690 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17691 {
17692         const char *val = NULL;
17693
17694         switch (r) {
17695                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17696                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17697                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17698                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17699                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17700                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17701                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17702                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17703                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17704                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17705                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17706                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17707                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17708                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17709                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17710                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17711                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17712                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17713                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17714                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17715                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17716                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17717                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17718                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17719                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17720                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17721                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17722                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17723         }
17724         ndr_print_enum(ndr, name, "ENUM", val, r);
17725 }
17726
17727 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17728 {
17729         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
17730         return NDR_ERR_SUCCESS;
17731 }
17732
17733 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17734 {
17735         uint16_t v;
17736         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
17737         *r = v;
17738         return NDR_ERR_SUCCESS;
17739 }
17740
17741 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17742 {
17743         const char *val = NULL;
17744
17745         switch (r) {
17746                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17747                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17748         }
17749         ndr_print_enum(ndr, name, "ENUM", val, r);
17750 }
17751
17752 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17753 {
17754         if (ndr_flags & NDR_SCALARS) {
17755                 int level = ndr_push_get_switch_value(ndr, r);
17756                 NDR_CHECK(ndr_push_union_align(ndr, 2));
17757                 switch (level) {
17758                         case PRINTER_NOTIFY_TYPE: {
17759                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17760                         break; }
17761
17762                         case JOB_NOTIFY_TYPE: {
17763                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17764                         break; }
17765
17766                         default: {
17767                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17768                         break; }
17769
17770                 }
17771         }
17772         if (ndr_flags & NDR_BUFFERS) {
17773                 int level = ndr_push_get_switch_value(ndr, r);
17774                 switch (level) {
17775                         case PRINTER_NOTIFY_TYPE:
17776                         break;
17777
17778                         case JOB_NOTIFY_TYPE:
17779                         break;
17780
17781                         default:
17782                         break;
17783
17784                 }
17785         }
17786         return NDR_ERR_SUCCESS;
17787 }
17788
17789 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17790 {
17791         int level;
17792         level = ndr_pull_get_switch_value(ndr, r);
17793         if (ndr_flags & NDR_SCALARS) {
17794                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
17795                 switch (level) {
17796                         case PRINTER_NOTIFY_TYPE: {
17797                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17798                         break; }
17799
17800                         case JOB_NOTIFY_TYPE: {
17801                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17802                         break; }
17803
17804                         default: {
17805                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17806                         break; }
17807
17808                 }
17809         }
17810         if (ndr_flags & NDR_BUFFERS) {
17811                 switch (level) {
17812                         case PRINTER_NOTIFY_TYPE:
17813                         break;
17814
17815                         case JOB_NOTIFY_TYPE:
17816                         break;
17817
17818                         default:
17819                         break;
17820
17821                 }
17822         }
17823         return NDR_ERR_SUCCESS;
17824 }
17825
17826 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17827 {
17828         uint32_t cntr_fields_1;
17829         if (ndr_flags & NDR_SCALARS) {
17830                 NDR_CHECK(ndr_push_align(ndr, 5));
17831                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17832                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17837                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17838         }
17839         if (ndr_flags & NDR_BUFFERS) {
17840                 if (r->fields) {
17841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
17842                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17843                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17844                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17845                         }
17846                 }
17847         }
17848         return NDR_ERR_SUCCESS;
17849 }
17850
17851 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17852 {
17853         uint32_t _ptr_fields;
17854         uint32_t cntr_fields_1;
17855         TALLOC_CTX *_mem_save_fields_0;
17856         TALLOC_CTX *_mem_save_fields_1;
17857         if (ndr_flags & NDR_SCALARS) {
17858                 NDR_CHECK(ndr_pull_align(ndr, 5));
17859                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17860                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17865                 if (_ptr_fields) {
17866                         NDR_PULL_ALLOC(ndr, r->fields);
17867                 } else {
17868                         r->fields = NULL;
17869                 }
17870                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17871         }
17872         if (ndr_flags & NDR_BUFFERS) {
17873                 if (r->fields) {
17874                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17875                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17877                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17878                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17879                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17880                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17881                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17882                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17883                         }
17884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17886                 }
17887                 if (r->fields) {
17888                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17889                 }
17890         }
17891         return NDR_ERR_SUCCESS;
17892 }
17893
17894 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17895 {
17896         uint32_t cntr_fields_1;
17897         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17898         ndr->depth++;
17899         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17900         ndr_print_uint16(ndr, "u1", r->u1);
17901         ndr_print_uint32(ndr, "u2", r->u2);
17902         ndr_print_uint32(ndr, "u3", r->u3);
17903         ndr_print_uint32(ndr, "count", r->count);
17904         ndr_print_ptr(ndr, "fields", r->fields);
17905         ndr->depth++;
17906         if (r->fields) {
17907                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17908                 ndr->depth++;
17909                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17910                         char *idx_1=NULL;
17911                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17912                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17913                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17914                                 free(idx_1);
17915                         }
17916                 }
17917                 ndr->depth--;
17918         }
17919         ndr->depth--;
17920         ndr->depth--;
17921 }
17922
17923 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17924 {
17925         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17926         return NDR_ERR_SUCCESS;
17927 }
17928
17929 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17930 {
17931         uint32_t v;
17932         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17933         *r = v;
17934         return NDR_ERR_SUCCESS;
17935 }
17936
17937 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17938 {
17939         ndr_print_uint32(ndr, name, r);
17940         ndr->depth++;
17941         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17942         ndr->depth--;
17943 }
17944
17945 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17946 {
17947         uint32_t cntr_types_1;
17948         if (ndr_flags & NDR_SCALARS) {
17949                 NDR_CHECK(ndr_push_align(ndr, 5));
17950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17951                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17953                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17954                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17955         }
17956         if (ndr_flags & NDR_BUFFERS) {
17957                 if (r->types) {
17958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
17959                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17960                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17961                         }
17962                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17963                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17964                         }
17965                 }
17966         }
17967         return NDR_ERR_SUCCESS;
17968 }
17969
17970 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17971 {
17972         uint32_t _ptr_types;
17973         uint32_t cntr_types_1;
17974         TALLOC_CTX *_mem_save_types_0;
17975         TALLOC_CTX *_mem_save_types_1;
17976         if (ndr_flags & NDR_SCALARS) {
17977                 NDR_CHECK(ndr_pull_align(ndr, 5));
17978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17979                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17982                 if (_ptr_types) {
17983                         NDR_PULL_ALLOC(ndr, r->types);
17984                 } else {
17985                         r->types = NULL;
17986                 }
17987                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17988         }
17989         if (ndr_flags & NDR_BUFFERS) {
17990                 if (r->types) {
17991                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17992                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17993                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17994                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17995                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17996                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17997                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17998                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17999                         }
18000                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18001                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18002                         }
18003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18005                 }
18006                 if (r->types) {
18007                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18008                 }
18009         }
18010         return NDR_ERR_SUCCESS;
18011 }
18012
18013 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18014 {
18015         uint32_t cntr_types_1;
18016         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18017         ndr->depth++;
18018         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18019         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18020         ndr_print_uint32(ndr, "count", r->count);
18021         ndr_print_ptr(ndr, "types", r->types);
18022         ndr->depth++;
18023         if (r->types) {
18024                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18025                 ndr->depth++;
18026                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18027                         char *idx_1=NULL;
18028                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18029                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18030                                 free(idx_1);
18031                         }
18032                 }
18033                 ndr->depth--;
18034         }
18035         ndr->depth--;
18036         ndr->depth--;
18037 }
18038
18039 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18040 {
18041         if (ndr_flags & NDR_SCALARS) {
18042                 NDR_CHECK(ndr_push_align(ndr, 5));
18043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18045                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18046         }
18047         if (ndr_flags & NDR_BUFFERS) {
18048                 if (r->string) {
18049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18051                 }
18052         }
18053         return NDR_ERR_SUCCESS;
18054 }
18055
18056 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18057 {
18058         uint32_t _ptr_string;
18059         TALLOC_CTX *_mem_save_string_0;
18060         if (ndr_flags & NDR_SCALARS) {
18061                 NDR_CHECK(ndr_pull_align(ndr, 5));
18062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18064                 if (_ptr_string) {
18065                         NDR_PULL_ALLOC(ndr, r->string);
18066                 } else {
18067                         r->string = NULL;
18068                 }
18069                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18070         }
18071         if (ndr_flags & NDR_BUFFERS) {
18072                 if (r->string) {
18073                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18074                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18075                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18076                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18078                 }
18079                 if (r->string) {
18080                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18081                 }
18082         }
18083         return NDR_ERR_SUCCESS;
18084 }
18085
18086 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18087 {
18088         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18089         ndr->depth++;
18090         ndr_print_uint32(ndr, "size", r->size);
18091         ndr_print_ptr(ndr, "string", r->string);
18092         ndr->depth++;
18093         if (r->string) {
18094                 ndr_print_string(ndr, "string", r->string);
18095         }
18096         ndr->depth--;
18097         ndr->depth--;
18098 }
18099
18100 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18101 {
18102         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18103         return NDR_ERR_SUCCESS;
18104 }
18105
18106 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18107 {
18108         uint32_t v;
18109         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18110         *r = v;
18111         return NDR_ERR_SUCCESS;
18112 }
18113
18114 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18115 {
18116         const char *val = NULL;
18117
18118         switch (r) {
18119                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18120                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18121                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18122                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18123                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18124         }
18125         ndr_print_enum(ndr, name, "ENUM", val, r);
18126 }
18127
18128 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18129 {
18130         if (ndr_flags & NDR_SCALARS) {
18131                 int level = ndr_push_get_switch_value(ndr, r);
18132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18133                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18134                 switch (level) {
18135                         case 1: {
18136                                 uint32_t cntr_integer_0;
18137                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18138                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18139                                 }
18140                         break; }
18141
18142                         case 2: {
18143                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18144                         break; }
18145
18146                         case 3: {
18147                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18148                         break; }
18149
18150                         case 4: {
18151                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18152                         break; }
18153
18154                         case 5: {
18155                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18156                         break; }
18157
18158                         default:
18159                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18160                 }
18161         }
18162         if (ndr_flags & NDR_BUFFERS) {
18163                 int level = ndr_push_get_switch_value(ndr, r);
18164                 switch (level) {
18165                         case 1:
18166                         break;
18167
18168                         case 2:
18169                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18170                         break;
18171
18172                         case 3:
18173                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18174                         break;
18175
18176                         case 4:
18177                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18178                         break;
18179
18180                         case 5:
18181                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18182                         break;
18183
18184                         default:
18185                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18186                 }
18187         }
18188         return NDR_ERR_SUCCESS;
18189 }
18190
18191 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18192 {
18193         int level;
18194         uint32_t _level;
18195         level = ndr_pull_get_switch_value(ndr, r);
18196         if (ndr_flags & NDR_SCALARS) {
18197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18198                 if (_level != level) {
18199                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18200                 }
18201                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18202                 switch (level) {
18203                         case 1: {
18204                                 uint32_t cntr_integer_0;
18205                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18206                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18207                                 }
18208                         break; }
18209
18210                         case 2: {
18211                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18212                         break; }
18213
18214                         case 3: {
18215                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18216                         break; }
18217
18218                         case 4: {
18219                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18220                         break; }
18221
18222                         case 5: {
18223                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18224                         break; }
18225
18226                         default:
18227                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18228                 }
18229         }
18230         if (ndr_flags & NDR_BUFFERS) {
18231                 switch (level) {
18232                         case 1:
18233                         break;
18234
18235                         case 2:
18236                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18237                         break;
18238
18239                         case 3:
18240                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18241                         break;
18242
18243                         case 4:
18244                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18245                         break;
18246
18247                         case 5:
18248                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18249                         break;
18250
18251                         default:
18252                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18253                 }
18254         }
18255         return NDR_ERR_SUCCESS;
18256 }
18257
18258 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18259 {
18260         int level;
18261         uint32_t cntr_integer_0;
18262         level = ndr_print_get_switch_value(ndr, r);
18263         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18264         switch (level) {
18265                 case 1:
18266                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18267                         ndr->depth++;
18268                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18269                                 char *idx_0=NULL;
18270                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18271                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18272                                         free(idx_0);
18273                                 }
18274                         }
18275                         ndr->depth--;
18276                 break;
18277
18278                 case 2:
18279                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18280                 break;
18281
18282                 case 3:
18283                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18284                 break;
18285
18286                 case 4:
18287                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18288                 break;
18289
18290                 case 5:
18291                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18292                 break;
18293
18294                 default:
18295                         ndr_print_bad_level(ndr, name, level);
18296         }
18297 }
18298
18299 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18300 {
18301         if (ndr_flags & NDR_SCALARS) {
18302                 NDR_CHECK(ndr_push_align(ndr, 5));
18303                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18304                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18305                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18306                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18308                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18309                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18310                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18311         }
18312         if (ndr_flags & NDR_BUFFERS) {
18313                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18314         }
18315         return NDR_ERR_SUCCESS;
18316 }
18317
18318 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18319 {
18320         if (ndr_flags & NDR_SCALARS) {
18321                 NDR_CHECK(ndr_pull_align(ndr, 5));
18322                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18323                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18324                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18325                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18327                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18328                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18329                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18330         }
18331         if (ndr_flags & NDR_BUFFERS) {
18332                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18333         }
18334         return NDR_ERR_SUCCESS;
18335 }
18336
18337 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18338 {
18339         ndr_print_struct(ndr, name, "spoolss_Notify");
18340         ndr->depth++;
18341         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18342         ndr_print_set_switch_value(ndr, &r->field, r->type);
18343         ndr_print_spoolss_Field(ndr, "field", &r->field);
18344         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18345         ndr_print_uint32(ndr, "job_id", r->job_id);
18346         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18347         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18348         ndr->depth--;
18349 }
18350
18351 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18352 {
18353         uint32_t cntr_notifies_0;
18354         if (ndr_flags & NDR_SCALARS) {
18355                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18356                 NDR_CHECK(ndr_push_align(ndr, 5));
18357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18360                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18361                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18362                 }
18363                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18364         }
18365         if (ndr_flags & NDR_BUFFERS) {
18366                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18367                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18368                 }
18369         }
18370         return NDR_ERR_SUCCESS;
18371 }
18372
18373 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18374 {
18375         uint32_t cntr_notifies_0;
18376         TALLOC_CTX *_mem_save_notifies_0;
18377         if (ndr_flags & NDR_SCALARS) {
18378                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18379                 NDR_CHECK(ndr_pull_align(ndr, 5));
18380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18383                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18384                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18385                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18386                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18387                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18388                 }
18389                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18390                 if (r->notifies) {
18391                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18392                 }
18393                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18394         }
18395         if (ndr_flags & NDR_BUFFERS) {
18396                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18397                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18398                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18399                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18400                 }
18401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18402         }
18403         return NDR_ERR_SUCCESS;
18404 }
18405
18406 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18407 {
18408         uint32_t cntr_notifies_0;
18409         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18410         ndr->depth++;
18411         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18412         ndr_print_uint32(ndr, "flags", r->flags);
18413         ndr_print_uint32(ndr, "count", r->count);
18414         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18415         ndr->depth++;
18416         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18417                 char *idx_0=NULL;
18418                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18419                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18420                         free(idx_0);
18421                 }
18422         }
18423         ndr->depth--;
18424         ndr->depth--;
18425 }
18426
18427 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18428 {
18429         if (ndr_flags & NDR_SCALARS) {
18430                 int level = ndr_push_get_switch_value(ndr, r);
18431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18432                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18433                 switch (level) {
18434                         case 0: {
18435                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18436                         break; }
18437
18438                         default:
18439                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18440                 }
18441         }
18442         if (ndr_flags & NDR_BUFFERS) {
18443                 int level = ndr_push_get_switch_value(ndr, r);
18444                 switch (level) {
18445                         case 0:
18446                                 if (r->info0) {
18447                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18448                                 }
18449                         break;
18450
18451                         default:
18452                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18453                 }
18454         }
18455         return NDR_ERR_SUCCESS;
18456 }
18457
18458 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18459 {
18460         int level;
18461         uint32_t _level;
18462         TALLOC_CTX *_mem_save_info0_0;
18463         level = ndr_pull_get_switch_value(ndr, r);
18464         if (ndr_flags & NDR_SCALARS) {
18465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18466                 if (_level != level) {
18467                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18468                 }
18469                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18470                 switch (level) {
18471                         case 0: {
18472                                 uint32_t _ptr_info0;
18473                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18474                                 if (_ptr_info0) {
18475                                         NDR_PULL_ALLOC(ndr, r->info0);
18476                                 } else {
18477                                         r->info0 = NULL;
18478                                 }
18479                         break; }
18480
18481                         default:
18482                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18483                 }
18484         }
18485         if (ndr_flags & NDR_BUFFERS) {
18486                 switch (level) {
18487                         case 0:
18488                                 if (r->info0) {
18489                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18490                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18491                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18492                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18493                                 }
18494                         break;
18495
18496                         default:
18497                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18498                 }
18499         }
18500         return NDR_ERR_SUCCESS;
18501 }
18502
18503 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18504 {
18505         int level;
18506         level = ndr_print_get_switch_value(ndr, r);
18507         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18508         switch (level) {
18509                 case 0:
18510                         ndr_print_ptr(ndr, "info0", r->info0);
18511                         ndr->depth++;
18512                         if (r->info0) {
18513                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18514                         }
18515                         ndr->depth--;
18516                 break;
18517
18518                 default:
18519                         ndr_print_bad_level(ndr, name, level);
18520         }
18521 }
18522
18523 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18524 {
18525         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18526         return NDR_ERR_SUCCESS;
18527 }
18528
18529 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18530 {
18531         uint32_t v;
18532         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18533         *r = v;
18534         return NDR_ERR_SUCCESS;
18535 }
18536
18537 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18538 {
18539         ndr_print_uint32(ndr, name, r);
18540         ndr->depth++;
18541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
18543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
18544         ndr->depth--;
18545 }
18546
18547 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
18548 {
18549         if (ndr_flags & NDR_SCALARS) {
18550                 NDR_CHECK(ndr_push_align(ndr, 5));
18551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18555                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18556                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18557                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18558                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18559         }
18560         if (ndr_flags & NDR_BUFFERS) {
18561                 if (r->client) {
18562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18565                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18566                 }
18567                 if (r->user) {
18568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18571                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18572                 }
18573         }
18574         return NDR_ERR_SUCCESS;
18575 }
18576
18577 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
18578 {
18579         uint32_t _ptr_client;
18580         TALLOC_CTX *_mem_save_client_0;
18581         uint32_t _ptr_user;
18582         TALLOC_CTX *_mem_save_user_0;
18583         if (ndr_flags & NDR_SCALARS) {
18584                 NDR_CHECK(ndr_pull_align(ndr, 5));
18585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18587                 if (_ptr_client) {
18588                         NDR_PULL_ALLOC(ndr, r->client);
18589                 } else {
18590                         r->client = NULL;
18591                 }
18592                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18593                 if (_ptr_user) {
18594                         NDR_PULL_ALLOC(ndr, r->user);
18595                 } else {
18596                         r->user = NULL;
18597                 }
18598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18599                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18600                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18601                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18602                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18603         }
18604         if (ndr_flags & NDR_BUFFERS) {
18605                 if (r->client) {
18606                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18607                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18610                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18611                                 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));
18612                         }
18613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18616                 }
18617                 if (r->user) {
18618                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18619                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18622                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18623                                 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));
18624                         }
18625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18628                 }
18629         }
18630         return NDR_ERR_SUCCESS;
18631 }
18632
18633 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
18634 {
18635         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
18636         ndr->depth++;
18637         ndr_print_uint32(ndr, "size", r->size);
18638         ndr_print_ptr(ndr, "client", r->client);
18639         ndr->depth++;
18640         if (r->client) {
18641                 ndr_print_string(ndr, "client", r->client);
18642         }
18643         ndr->depth--;
18644         ndr_print_ptr(ndr, "user", r->user);
18645         ndr->depth++;
18646         if (r->user) {
18647                 ndr_print_string(ndr, "user", r->user);
18648         }
18649         ndr->depth--;
18650         ndr_print_uint32(ndr, "build", r->build);
18651         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18652         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18653         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18654         ndr->depth--;
18655 }
18656
18657 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
18658 {
18659         if (ndr_flags & NDR_SCALARS) {
18660                 NDR_CHECK(ndr_push_align(ndr, 4));
18661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
18662                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
18663         }
18664         if (ndr_flags & NDR_BUFFERS) {
18665         }
18666         return NDR_ERR_SUCCESS;
18667 }
18668
18669 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
18670 {
18671         if (ndr_flags & NDR_SCALARS) {
18672                 NDR_CHECK(ndr_pull_align(ndr, 4));
18673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
18674                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
18675         }
18676         if (ndr_flags & NDR_BUFFERS) {
18677         }
18678         return NDR_ERR_SUCCESS;
18679 }
18680
18681 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18682 {
18683         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18684         ndr->depth++;
18685         ndr_print_uint32(ndr, "not_used", r->not_used);
18686         ndr->depth--;
18687 }
18688
18689 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18690 {
18691         if (ndr_flags & NDR_SCALARS) {
18692                 NDR_CHECK(ndr_push_align(ndr, 5));
18693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18699                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18700                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18701                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18702                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18703                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18704         }
18705         if (ndr_flags & NDR_BUFFERS) {
18706                 if (r->client) {
18707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18710                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18711                 }
18712                 if (r->user) {
18713                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18717                 }
18718         }
18719         return NDR_ERR_SUCCESS;
18720 }
18721
18722 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18723 {
18724         uint32_t _ptr_client;
18725         TALLOC_CTX *_mem_save_client_0;
18726         uint32_t _ptr_user;
18727         TALLOC_CTX *_mem_save_user_0;
18728         if (ndr_flags & NDR_SCALARS) {
18729                 NDR_CHECK(ndr_pull_align(ndr, 5));
18730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18734                 if (_ptr_client) {
18735                         NDR_PULL_ALLOC(ndr, r->client);
18736                 } else {
18737                         r->client = NULL;
18738                 }
18739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18740                 if (_ptr_user) {
18741                         NDR_PULL_ALLOC(ndr, r->user);
18742                 } else {
18743                         r->user = NULL;
18744                 }
18745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18746                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18747                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18748                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18749                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18750                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18751         }
18752         if (ndr_flags & NDR_BUFFERS) {
18753                 if (r->client) {
18754                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18755                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18756                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18757                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18758                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18759                                 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));
18760                         }
18761                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18762                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18764                 }
18765                 if (r->user) {
18766                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18767                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18769                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18770                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18771                                 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));
18772                         }
18773                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18774                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18776                 }
18777         }
18778         return NDR_ERR_SUCCESS;
18779 }
18780
18781 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18782 {
18783         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18784         ndr->depth++;
18785         ndr_print_uint32(ndr, "size", r->size);
18786         ndr_print_uint32(ndr, "flags", r->flags);
18787         ndr_print_uint32(ndr, "size2", r->size2);
18788         ndr_print_ptr(ndr, "client", r->client);
18789         ndr->depth++;
18790         if (r->client) {
18791                 ndr_print_string(ndr, "client", r->client);
18792         }
18793         ndr->depth--;
18794         ndr_print_ptr(ndr, "user", r->user);
18795         ndr->depth++;
18796         if (r->user) {
18797                 ndr_print_string(ndr, "user", r->user);
18798         }
18799         ndr->depth--;
18800         ndr_print_uint32(ndr, "build", r->build);
18801         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18802         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18803         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18804         ndr_print_udlong(ndr, "reserved", r->reserved);
18805         ndr->depth--;
18806 }
18807
18808 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18809 {
18810         if (ndr_flags & NDR_SCALARS) {
18811                 int level = ndr_push_get_switch_value(ndr, r);
18812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18813                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18814                 switch (level) {
18815                         case 1: {
18816                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18817                         break; }
18818
18819                         case 2: {
18820                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18821                         break; }
18822
18823                         case 3: {
18824                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18825                         break; }
18826
18827                         default:
18828                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18829                 }
18830         }
18831         if (ndr_flags & NDR_BUFFERS) {
18832                 int level = ndr_push_get_switch_value(ndr, r);
18833                 switch (level) {
18834                         case 1:
18835                                 if (r->level1) {
18836                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18837                                 }
18838                         break;
18839
18840                         case 2:
18841                                 if (r->level2) {
18842                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18843                                 }
18844                         break;
18845
18846                         case 3:
18847                                 if (r->level3) {
18848                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18849                                 }
18850                         break;
18851
18852                         default:
18853                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18854                 }
18855         }
18856         return NDR_ERR_SUCCESS;
18857 }
18858
18859 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18860 {
18861         int level;
18862         uint32_t _level;
18863         TALLOC_CTX *_mem_save_level1_0;
18864         TALLOC_CTX *_mem_save_level2_0;
18865         TALLOC_CTX *_mem_save_level3_0;
18866         level = ndr_pull_get_switch_value(ndr, r);
18867         if (ndr_flags & NDR_SCALARS) {
18868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18869                 if (_level != level) {
18870                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18871                 }
18872                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18873                 switch (level) {
18874                         case 1: {
18875                                 uint32_t _ptr_level1;
18876                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18877                                 if (_ptr_level1) {
18878                                         NDR_PULL_ALLOC(ndr, r->level1);
18879                                 } else {
18880                                         r->level1 = NULL;
18881                                 }
18882                         break; }
18883
18884                         case 2: {
18885                                 uint32_t _ptr_level2;
18886                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18887                                 if (_ptr_level2) {
18888                                         NDR_PULL_ALLOC(ndr, r->level2);
18889                                 } else {
18890                                         r->level2 = NULL;
18891                                 }
18892                         break; }
18893
18894                         case 3: {
18895                                 uint32_t _ptr_level3;
18896                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18897                                 if (_ptr_level3) {
18898                                         NDR_PULL_ALLOC(ndr, r->level3);
18899                                 } else {
18900                                         r->level3 = NULL;
18901                                 }
18902                         break; }
18903
18904                         default:
18905                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18906                 }
18907         }
18908         if (ndr_flags & NDR_BUFFERS) {
18909                 switch (level) {
18910                         case 1:
18911                                 if (r->level1) {
18912                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18913                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18914                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18915                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18916                                 }
18917                         break;
18918
18919                         case 2:
18920                                 if (r->level2) {
18921                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18922                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18923                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18924                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18925                                 }
18926                         break;
18927
18928                         case 3:
18929                                 if (r->level3) {
18930                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18931                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18932                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18933                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18934                                 }
18935                         break;
18936
18937                         default:
18938                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18939                 }
18940         }
18941         return NDR_ERR_SUCCESS;
18942 }
18943
18944 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18945 {
18946         int level;
18947         level = ndr_print_get_switch_value(ndr, r);
18948         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18949         switch (level) {
18950                 case 1:
18951                         ndr_print_ptr(ndr, "level1", r->level1);
18952                         ndr->depth++;
18953                         if (r->level1) {
18954                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18955                         }
18956                         ndr->depth--;
18957                 break;
18958
18959                 case 2:
18960                         ndr_print_ptr(ndr, "level2", r->level2);
18961                         ndr->depth++;
18962                         if (r->level2) {
18963                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18964                         }
18965                         ndr->depth--;
18966                 break;
18967
18968                 case 3:
18969                         ndr_print_ptr(ndr, "level3", r->level3);
18970                         ndr->depth++;
18971                         if (r->level3) {
18972                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18973                         }
18974                         ndr->depth--;
18975                 break;
18976
18977                 default:
18978                         ndr_print_bad_level(ndr, name, level);
18979         }
18980 }
18981
18982 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18983 {
18984         if (ndr_flags & NDR_SCALARS) {
18985                 NDR_CHECK(ndr_push_align(ndr, 5));
18986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18987                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18988                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18989                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18990         }
18991         if (ndr_flags & NDR_BUFFERS) {
18992                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18993         }
18994         return NDR_ERR_SUCCESS;
18995 }
18996
18997 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18998 {
18999         if (ndr_flags & NDR_SCALARS) {
19000                 NDR_CHECK(ndr_pull_align(ndr, 5));
19001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19002                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19003                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19004                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19005         }
19006         if (ndr_flags & NDR_BUFFERS) {
19007                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19008         }
19009         return NDR_ERR_SUCCESS;
19010 }
19011
19012 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19013 {
19014         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19015         ndr->depth++;
19016         ndr_print_uint32(ndr, "level", r->level);
19017         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19018         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19019         ndr->depth--;
19020 }
19021
19022 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19023 {
19024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19025         return NDR_ERR_SUCCESS;
19026 }
19027
19028 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19029 {
19030         uint32_t v;
19031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19032         *r = v;
19033         return NDR_ERR_SUCCESS;
19034 }
19035
19036 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19037 {
19038         ndr_print_uint32(ndr, name, r);
19039         ndr->depth++;
19040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19043         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19045         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19046         ndr->depth--;
19047 }
19048
19049 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19050 {
19051         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19052         if (ndr_flags & NDR_SCALARS) {
19053                 NDR_CHECK(ndr_push_align(ndr, 5));
19054                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19055                 {
19056                         uint32_t _flags_save_string = ndr->flags;
19057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19058                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19059                         ndr->flags = _flags_save_string;
19060                 }
19061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19062                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19063                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19065                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19066         }
19067         if (ndr_flags & NDR_BUFFERS) {
19068                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19069                 {
19070                         uint32_t _flags_save_string = ndr->flags;
19071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19072                         if (r->value_name) {
19073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
19074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19075                         }
19076                         ndr->flags = _flags_save_string;
19077                 }
19078                 if (r->data) {
19079                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
19080                         {
19081                                 struct ndr_push *_ndr_data;
19082                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19083                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19084                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19085                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19086                         }
19087                 }
19088         }
19089         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19090         return NDR_ERR_SUCCESS;
19091 }
19092
19093 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19094 {
19095         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19096         uint32_t _ptr_value_name;
19097         TALLOC_CTX *_mem_save_value_name_0;
19098         uint32_t _ptr_data;
19099         TALLOC_CTX *_mem_save_data_0;
19100         if (ndr_flags & NDR_SCALARS) {
19101                 NDR_CHECK(ndr_pull_align(ndr, 5));
19102                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19103                 {
19104                         uint32_t _flags_save_string = ndr->flags;
19105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19106                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19107                         if (_ptr_value_name) {
19108                                 NDR_PULL_ALLOC(ndr, r->value_name);
19109                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19110                         } else {
19111                                 r->value_name = NULL;
19112                         }
19113                         ndr->flags = _flags_save_string;
19114                 }
19115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19116                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19118                 if (_ptr_data) {
19119                         NDR_PULL_ALLOC(ndr, r->data);
19120                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19121                 } else {
19122                         r->data = NULL;
19123                 }
19124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19125                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19126         }
19127         if (ndr_flags & NDR_BUFFERS) {
19128                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19129                 {
19130                         uint32_t _flags_save_string = ndr->flags;
19131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19132                         if (r->value_name) {
19133                                 uint32_t _relative_save_offset;
19134                                 _relative_save_offset = ndr->offset;
19135                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19136                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19137                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19138                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19139                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19140                                 ndr->offset = _relative_save_offset;
19141                         }
19142                         ndr->flags = _flags_save_string;
19143                 }
19144                 if (r->data) {
19145                         uint32_t _relative_save_offset;
19146                         _relative_save_offset = ndr->offset;
19147                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19148                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19149                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19150                         {
19151                                 struct ndr_pull *_ndr_data;
19152                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19153                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19154                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19155                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19156                         }
19157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19158                         ndr->offset = _relative_save_offset;
19159                 }
19160         }
19161         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19162         return NDR_ERR_SUCCESS;
19163 }
19164
19165 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19166 {
19167         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19168         ndr->depth++;
19169         ndr_print_ptr(ndr, "value_name", r->value_name);
19170         ndr->depth++;
19171         if (r->value_name) {
19172                 ndr_print_string(ndr, "value_name", r->value_name);
19173         }
19174         ndr->depth--;
19175         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19176         ndr_print_winreg_Type(ndr, "type", r->type);
19177         ndr_print_ptr(ndr, "data", r->data);
19178         ndr->depth++;
19179         if (r->data) {
19180                 ndr_print_set_switch_value(ndr, r->data, r->type);
19181                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19182         }
19183         ndr->depth--;
19184         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);
19185         ndr->depth--;
19186 }
19187
19188 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19189 {
19190         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19191 }
19192
19193 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
19194 {
19195         if (ndr_flags & NDR_SCALARS) {
19196                 int level = ndr_push_get_switch_value(ndr, r);
19197                 NDR_CHECK(ndr_push_union_align(ndr, 4));
19198                 switch (level) {
19199                         case 0: {
19200                         break; }
19201
19202                         case 1: {
19203                         break; }
19204
19205                         default: {
19206                                 {
19207                                         uint32_t _flags_save_string_array = ndr->flags;
19208                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19209                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
19210                                         ndr->flags = _flags_save_string_array;
19211                                 }
19212                         break; }
19213
19214                 }
19215         }
19216         if (ndr_flags & NDR_BUFFERS) {
19217                 int level = ndr_push_get_switch_value(ndr, r);
19218                 switch (level) {
19219                         case 0:
19220                         break;
19221
19222                         case 1:
19223                         break;
19224
19225                         default:
19226                         break;
19227
19228                 }
19229         }
19230         return NDR_ERR_SUCCESS;
19231 }
19232
19233 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
19234 {
19235         int level;
19236         level = ndr_pull_get_switch_value(ndr, r);
19237         if (ndr_flags & NDR_SCALARS) {
19238                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
19239                 switch (level) {
19240                         case 0: {
19241                         break; }
19242
19243                         case 1: {
19244                         break; }
19245
19246                         default: {
19247                                 {
19248                                         uint32_t _flags_save_string_array = ndr->flags;
19249                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19250                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
19251                                         ndr->flags = _flags_save_string_array;
19252                                 }
19253                         break; }
19254
19255                 }
19256         }
19257         if (ndr_flags & NDR_BUFFERS) {
19258                 switch (level) {
19259                         case 0:
19260                         break;
19261
19262                         case 1:
19263                         break;
19264
19265                         default:
19266                         break;
19267
19268                 }
19269         }
19270         return NDR_ERR_SUCCESS;
19271 }
19272
19273 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
19274 {
19275         int level;
19276         level = ndr_print_get_switch_value(ndr, r);
19277         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
19278         switch (level) {
19279                 case 0:
19280                 break;
19281
19282                 case 1:
19283                 break;
19284
19285                 default:
19286                         ndr_print_string_array(ndr, "string_array", r->string_array);
19287                 break;
19288
19289         }
19290 }
19291
19292 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19293 {
19294         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19295         return NDR_ERR_SUCCESS;
19296 }
19297
19298 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19299 {
19300         uint32_t v;
19301         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19302         *r = v;
19303         return NDR_ERR_SUCCESS;
19304 }
19305
19306 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19307 {
19308         ndr_print_uint32(ndr, name, r);
19309         ndr->depth++;
19310         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19311         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19312         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19313         ndr->depth--;
19314 }
19315
19316 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19317 {
19318         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19319         return NDR_ERR_SUCCESS;
19320 }
19321
19322 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19323 {
19324         uint32_t v;
19325         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19326         *r = v;
19327         return NDR_ERR_SUCCESS;
19328 }
19329
19330 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19331 {
19332         const char *val = NULL;
19333
19334         switch (r) {
19335                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19336                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19337         }
19338         ndr_print_enum(ndr, name, "ENUM", val, r);
19339 }
19340
19341 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19342 {
19343         if (ndr_flags & NDR_SCALARS) {
19344                 NDR_CHECK(ndr_push_align(ndr, 4));
19345                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19347                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19350                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19351                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19353                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19354                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19355                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19356                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19360                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19361         }
19362         if (ndr_flags & NDR_BUFFERS) {
19363         }
19364         return NDR_ERR_SUCCESS;
19365 }
19366
19367 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19368 {
19369         if (ndr_flags & NDR_SCALARS) {
19370                 NDR_CHECK(ndr_pull_align(ndr, 4));
19371                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19373                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19376                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19377                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19379                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19380                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19381                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19382                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19386                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19387         }
19388         if (ndr_flags & NDR_BUFFERS) {
19389         }
19390         return NDR_ERR_SUCCESS;
19391 }
19392
19393 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19394 {
19395         ndr_print_struct(ndr, name, "spoolss_PortData1");
19396         ndr->depth++;
19397         ndr_print_string(ndr, "portname", r->portname);
19398         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19399         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19400         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19401         ndr_print_uint32(ndr, "reserved", r->reserved);
19402         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19403         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19404         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19405         ndr_print_string(ndr, "queue", r->queue);
19406         ndr_print_string(ndr, "ip_address", r->ip_address);
19407         ndr_print_string(ndr, "hardware_address", r->hardware_address);
19408         ndr_print_string(ndr, "device_type", r->device_type);
19409         ndr_print_uint32(ndr, "port_number", r->port_number);
19410         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19411         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19412         ndr->depth--;
19413 }
19414
19415 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19416 {
19417         if (ndr_flags & NDR_SCALARS) {
19418                 NDR_CHECK(ndr_push_align(ndr, 4));
19419                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19421                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19424                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19425                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19427                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19428                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19433                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19434         }
19435         if (ndr_flags & NDR_BUFFERS) {
19436         }
19437         return NDR_ERR_SUCCESS;
19438 }
19439
19440 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19441 {
19442         if (ndr_flags & NDR_SCALARS) {
19443                 NDR_CHECK(ndr_pull_align(ndr, 4));
19444                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19446                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19449                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19450                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19452                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19453                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19458                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19459         }
19460         if (ndr_flags & NDR_BUFFERS) {
19461         }
19462         return NDR_ERR_SUCCESS;
19463 }
19464
19465 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19466 {
19467         ndr_print_struct(ndr, name, "spoolss_PortData2");
19468         ndr->depth++;
19469         ndr_print_string(ndr, "portname", r->portname);
19470         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19471         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19472         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19473         ndr_print_uint32(ndr, "reserved", r->reserved);
19474         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19475         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19476         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19477         ndr_print_string(ndr, "queue", r->queue);
19478         ndr_print_string(ndr, "device_type", r->device_type);
19479         ndr_print_uint32(ndr, "port_number", r->port_number);
19480         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19481         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19482         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19483         ndr->depth--;
19484 }
19485
19486 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19487 {
19488         if (ndr_flags & NDR_SCALARS) {
19489                 NDR_CHECK(ndr_push_align(ndr, 4));
19490                 {
19491                         uint32_t _flags_save_string = ndr->flags;
19492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19493                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19494                         ndr->flags = _flags_save_string;
19495                 }
19496                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19497         }
19498         if (ndr_flags & NDR_BUFFERS) {
19499         }
19500         return NDR_ERR_SUCCESS;
19501 }
19502
19503 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19504 {
19505         if (ndr_flags & NDR_SCALARS) {
19506                 NDR_CHECK(ndr_pull_align(ndr, 4));
19507                 {
19508                         uint32_t _flags_save_string = ndr->flags;
19509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19510                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19511                         ndr->flags = _flags_save_string;
19512                 }
19513                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19514         }
19515         if (ndr_flags & NDR_BUFFERS) {
19516         }
19517         return NDR_ERR_SUCCESS;
19518 }
19519
19520 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19521 {
19522         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19523         ndr->depth++;
19524         ndr_print_string(ndr, "dll_name", r->dll_name);
19525         ndr->depth--;
19526 }
19527
19528 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19529 {
19530         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19531         return NDR_ERR_SUCCESS;
19532 }
19533
19534 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19535 {
19536         uint32_t v;
19537         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19538         *r = v;
19539         return NDR_ERR_SUCCESS;
19540 }
19541
19542 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19543 {
19544         ndr_print_uint32(ndr, name, r);
19545         ndr->depth++;
19546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
19547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
19548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
19549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
19550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
19551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
19552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
19553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
19554         ndr->depth--;
19555 }
19556
19557 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
19558 {
19559         if (ndr_flags & NDR_SCALARS) {
19560                 NDR_CHECK(ndr_push_align(ndr, 8));
19561                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19562                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
19563                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
19564                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
19565                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
19566         }
19567         if (ndr_flags & NDR_BUFFERS) {
19568         }
19569         return NDR_ERR_SUCCESS;
19570 }
19571
19572 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
19573 {
19574         if (ndr_flags & NDR_SCALARS) {
19575                 NDR_CHECK(ndr_pull_align(ndr, 8));
19576                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19577                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
19578                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
19579                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
19580                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
19581         }
19582         if (ndr_flags & NDR_BUFFERS) {
19583         }
19584         return NDR_ERR_SUCCESS;
19585 }
19586
19587 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
19588 {
19589         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
19590         ndr->depth++;
19591         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
19592         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
19593         ndr_print_hyper(ndr, "driver_version", r->driver_version);
19594         ndr_print_string(ndr, "formname", r->formname);
19595         ndr->depth--;
19596 }
19597
19598 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
19599 {
19600         if (flags & NDR_IN) {
19601                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
19602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19603                 if (r->in.server) {
19604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19607                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19608                 }
19609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19611                 if (r->in.buffer) {
19612                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19613                 }
19614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19615         }
19616         if (flags & NDR_OUT) {
19617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19618                 if (r->out.info) {
19619                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19620                 }
19621                 if (r->out.needed == NULL) {
19622                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19623                 }
19624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19625                 if (r->out.count == NULL) {
19626                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19627                 }
19628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19629                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19630         }
19631         return NDR_ERR_SUCCESS;
19632 }
19633
19634 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
19635 {
19636         uint32_t _ptr_server;
19637         uint32_t _ptr_buffer;
19638         uint32_t _ptr_info;
19639         TALLOC_CTX *_mem_save_server_0;
19640         TALLOC_CTX *_mem_save_buffer_0;
19641         TALLOC_CTX *_mem_save_info_0;
19642         TALLOC_CTX *_mem_save_needed_0;
19643         TALLOC_CTX *_mem_save_count_0;
19644         if (flags & NDR_IN) {
19645                 ZERO_STRUCT(r->out);
19646
19647                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
19648                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19649                 if (_ptr_server) {
19650                         NDR_PULL_ALLOC(ndr, r->in.server);
19651                 } else {
19652                         r->in.server = NULL;
19653                 }
19654                 if (r->in.server) {
19655                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19656                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19659                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
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->in.server), ndr_get_array_length(ndr, &r->in.server));
19661                         }
19662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19665                 }
19666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19667                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19668                 if (_ptr_buffer) {
19669                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19670                 } else {
19671                         r->in.buffer = NULL;
19672                 }
19673                 if (r->in.buffer) {
19674                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19675                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19676                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19678                 }
19679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19680                 NDR_PULL_ALLOC(ndr, r->out.needed);
19681                 ZERO_STRUCTP(r->out.needed);
19682                 NDR_PULL_ALLOC(ndr, r->out.count);
19683                 ZERO_STRUCTP(r->out.count);
19684         }
19685         if (flags & NDR_OUT) {
19686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19687                 if (_ptr_info) {
19688                         NDR_PULL_ALLOC(ndr, r->out.info);
19689                 } else {
19690                         r->out.info = NULL;
19691                 }
19692                 if (r->out.info) {
19693                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19694                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19695                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19697                 }
19698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19699                         NDR_PULL_ALLOC(ndr, r->out.needed);
19700                 }
19701                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19702                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19704                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19706                         NDR_PULL_ALLOC(ndr, r->out.count);
19707                 }
19708                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19709                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19712                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19713         }
19714         return NDR_ERR_SUCCESS;
19715 }
19716
19717 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
19718 {
19719         uint32_t cntr_info_0;
19720         if (flags & NDR_IN) {
19721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19723         }
19724         if (flags & NDR_OUT) {
19725                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19726                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19727                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19728                 }
19729                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19730                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19731                 }
19732         }
19733         return NDR_ERR_SUCCESS;
19734 }
19735
19736 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
19737 {
19738         uint32_t cntr_info_0;
19739         TALLOC_CTX *_mem_save_info_0;
19740         if (flags & NDR_IN) {
19741                 ZERO_STRUCT(r->out);
19742
19743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19745         }
19746         if (flags & NDR_OUT) {
19747                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19748                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19749                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19750                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19751                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19752                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19753                 }
19754                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19755                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19756                 }
19757                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19758         }
19759         return NDR_ERR_SUCCESS;
19760 }
19761
19762 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
19763 {
19764         uint32_t cntr_info_2;
19765         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
19766         ndr->depth++;
19767         if (flags & NDR_SET_VALUES) {
19768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19769         }
19770         if (flags & NDR_IN) {
19771                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
19772                 ndr->depth++;
19773                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
19774                 ndr_print_ptr(ndr, "server", r->in.server);
19775                 ndr->depth++;
19776                 if (r->in.server) {
19777                         ndr_print_string(ndr, "server", r->in.server);
19778                 }
19779                 ndr->depth--;
19780                 ndr_print_uint32(ndr, "level", r->in.level);
19781                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19782                 ndr->depth++;
19783                 if (r->in.buffer) {
19784                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19785                 }
19786                 ndr->depth--;
19787                 ndr_print_uint32(ndr, "offered", r->in.offered);
19788                 ndr->depth--;
19789         }
19790         if (flags & NDR_OUT) {
19791                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
19792                 ndr->depth++;
19793                 ndr_print_ptr(ndr, "count", r->out.count);
19794                 ndr->depth++;
19795                 ndr_print_uint32(ndr, "count", *r->out.count);
19796                 ndr->depth--;
19797                 ndr_print_ptr(ndr, "info", r->out.info);
19798                 ndr->depth++;
19799                 ndr_print_ptr(ndr, "info", *r->out.info);
19800                 ndr->depth++;
19801                 if (*r->out.info) {
19802                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19803                         ndr->depth++;
19804                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19805                                 char *idx_2=NULL;
19806                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19807                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19808                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19809                                         free(idx_2);
19810                                 }
19811                         }
19812                         ndr->depth--;
19813                 }
19814                 ndr->depth--;
19815                 ndr->depth--;
19816                 ndr_print_ptr(ndr, "needed", r->out.needed);
19817                 ndr->depth++;
19818                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19819                 ndr->depth--;
19820                 ndr_print_WERROR(ndr, "result", r->out.result);
19821                 ndr->depth--;
19822         }
19823         ndr->depth--;
19824 }
19825
19826 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
19827 {
19828         if (flags & NDR_IN) {
19829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
19830                 if (r->in.printername) {
19831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19834                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19835                 }
19836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19837                 if (r->in.datatype) {
19838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19842                 }
19843                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19844                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19845         }
19846         if (flags & NDR_OUT) {
19847                 if (r->out.handle == NULL) {
19848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19849                 }
19850                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19851                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19852         }
19853         return NDR_ERR_SUCCESS;
19854 }
19855
19856 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19857 {
19858         uint32_t _ptr_printername;
19859         uint32_t _ptr_datatype;
19860         TALLOC_CTX *_mem_save_printername_0;
19861         TALLOC_CTX *_mem_save_datatype_0;
19862         TALLOC_CTX *_mem_save_handle_0;
19863         if (flags & NDR_IN) {
19864                 ZERO_STRUCT(r->out);
19865
19866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19867                 if (_ptr_printername) {
19868                         NDR_PULL_ALLOC(ndr, r->in.printername);
19869                 } else {
19870                         r->in.printername = NULL;
19871                 }
19872                 if (r->in.printername) {
19873                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19874                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19877                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19878                                 return 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));
19879                         }
19880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19883                 }
19884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19885                 if (_ptr_datatype) {
19886                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19887                 } else {
19888                         r->in.datatype = NULL;
19889                 }
19890                 if (r->in.datatype) {
19891                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19895                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19896                                 return 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));
19897                         }
19898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19899                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19901                 }
19902                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19903                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19904                 NDR_PULL_ALLOC(ndr, r->out.handle);
19905                 ZERO_STRUCTP(r->out.handle);
19906         }
19907         if (flags & NDR_OUT) {
19908                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19909                         NDR_PULL_ALLOC(ndr, r->out.handle);
19910                 }
19911                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19912                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19913                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19914                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19915                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19916         }
19917         return NDR_ERR_SUCCESS;
19918 }
19919
19920 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19921 {
19922         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19923         ndr->depth++;
19924         if (flags & NDR_SET_VALUES) {
19925                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19926         }
19927         if (flags & NDR_IN) {
19928                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19929                 ndr->depth++;
19930                 ndr_print_ptr(ndr, "printername", r->in.printername);
19931                 ndr->depth++;
19932                 if (r->in.printername) {
19933                         ndr_print_string(ndr, "printername", r->in.printername);
19934                 }
19935                 ndr->depth--;
19936                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19937                 ndr->depth++;
19938                 if (r->in.datatype) {
19939                         ndr_print_string(ndr, "datatype", r->in.datatype);
19940                 }
19941                 ndr->depth--;
19942                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19943                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19944                 ndr->depth--;
19945         }
19946         if (flags & NDR_OUT) {
19947                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19948                 ndr->depth++;
19949                 ndr_print_ptr(ndr, "handle", r->out.handle);
19950                 ndr->depth++;
19951                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19952                 ndr->depth--;
19953                 ndr_print_WERROR(ndr, "result", r->out.result);
19954                 ndr->depth--;
19955         }
19956         ndr->depth--;
19957 }
19958
19959 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19960 {
19961         if (flags & NDR_IN) {
19962                 if (r->in.handle == NULL) {
19963                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19964                 }
19965                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19968                 if (r->in.ctr) {
19969                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19970                 }
19971                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19972         }
19973         if (flags & NDR_OUT) {
19974                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19975         }
19976         return NDR_ERR_SUCCESS;
19977 }
19978
19979 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19980 {
19981         uint32_t _ptr_ctr;
19982         TALLOC_CTX *_mem_save_handle_0;
19983         TALLOC_CTX *_mem_save_ctr_0;
19984         if (flags & NDR_IN) {
19985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19986                         NDR_PULL_ALLOC(ndr, r->in.handle);
19987                 }
19988                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19989                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19990                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19994                 if (_ptr_ctr) {
19995                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19996                 } else {
19997                         r->in.ctr = NULL;
19998                 }
19999                 if (r->in.ctr) {
20000                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20001                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20002                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20004                 }
20005                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20006         }
20007         if (flags & NDR_OUT) {
20008                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20009         }
20010         return NDR_ERR_SUCCESS;
20011 }
20012
20013 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20014 {
20015         ndr_print_struct(ndr, name, "spoolss_SetJob");
20016         ndr->depth++;
20017         if (flags & NDR_SET_VALUES) {
20018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20019         }
20020         if (flags & NDR_IN) {
20021                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20022                 ndr->depth++;
20023                 ndr_print_ptr(ndr, "handle", r->in.handle);
20024                 ndr->depth++;
20025                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20026                 ndr->depth--;
20027                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20028                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20029                 ndr->depth++;
20030                 if (r->in.ctr) {
20031                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20032                 }
20033                 ndr->depth--;
20034                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20035                 ndr->depth--;
20036         }
20037         if (flags & NDR_OUT) {
20038                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20039                 ndr->depth++;
20040                 ndr_print_WERROR(ndr, "result", r->out.result);
20041                 ndr->depth--;
20042         }
20043         ndr->depth--;
20044 }
20045
20046 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20047 {
20048         if (flags & NDR_IN) {
20049                 if (r->in.handle == NULL) {
20050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20051                 }
20052                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20056                 if (r->in.buffer) {
20057                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20058                 }
20059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20060         }
20061         if (flags & NDR_OUT) {
20062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20063                 if (r->out.info) {
20064                         {
20065                                 struct ndr_push *_ndr_info;
20066                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20067                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20068                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20069                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20070                         }
20071                 }
20072                 if (r->out.needed == NULL) {
20073                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20074                 }
20075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20076                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20077         }
20078         return NDR_ERR_SUCCESS;
20079 }
20080
20081 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20082 {
20083         uint32_t _ptr_buffer;
20084         uint32_t _ptr_info;
20085         TALLOC_CTX *_mem_save_handle_0;
20086         TALLOC_CTX *_mem_save_buffer_0;
20087         TALLOC_CTX *_mem_save_info_0;
20088         TALLOC_CTX *_mem_save_needed_0;
20089         if (flags & NDR_IN) {
20090                 ZERO_STRUCT(r->out);
20091
20092                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20093                         NDR_PULL_ALLOC(ndr, r->in.handle);
20094                 }
20095                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20096                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20097                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20099                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20102                 if (_ptr_buffer) {
20103                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20104                 } else {
20105                         r->in.buffer = NULL;
20106                 }
20107                 if (r->in.buffer) {
20108                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20109                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20110                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20112                 }
20113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20114                 NDR_PULL_ALLOC(ndr, r->out.needed);
20115                 ZERO_STRUCTP(r->out.needed);
20116         }
20117         if (flags & NDR_OUT) {
20118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20119                 if (_ptr_info) {
20120                         NDR_PULL_ALLOC(ndr, r->out.info);
20121                 } else {
20122                         r->out.info = NULL;
20123                 }
20124                 if (r->out.info) {
20125                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20126                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20127                         {
20128                                 struct ndr_pull *_ndr_info;
20129                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20130                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20131                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20132                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20133                         }
20134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20135                 }
20136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20137                         NDR_PULL_ALLOC(ndr, r->out.needed);
20138                 }
20139                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20140                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20144         }
20145         return NDR_ERR_SUCCESS;
20146 }
20147
20148 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20149 {
20150         ndr_print_struct(ndr, name, "spoolss_GetJob");
20151         ndr->depth++;
20152         if (flags & NDR_SET_VALUES) {
20153                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20154         }
20155         if (flags & NDR_IN) {
20156                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
20157                 ndr->depth++;
20158                 ndr_print_ptr(ndr, "handle", r->in.handle);
20159                 ndr->depth++;
20160                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20161                 ndr->depth--;
20162                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20163                 ndr_print_uint32(ndr, "level", r->in.level);
20164                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20165                 ndr->depth++;
20166                 if (r->in.buffer) {
20167                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20168                 }
20169                 ndr->depth--;
20170                 ndr_print_uint32(ndr, "offered", r->in.offered);
20171                 ndr->depth--;
20172         }
20173         if (flags & NDR_OUT) {
20174                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
20175                 ndr->depth++;
20176                 ndr_print_ptr(ndr, "info", r->out.info);
20177                 ndr->depth++;
20178                 if (r->out.info) {
20179                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20180                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20181                 }
20182                 ndr->depth--;
20183                 ndr_print_ptr(ndr, "needed", r->out.needed);
20184                 ndr->depth++;
20185                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20186                 ndr->depth--;
20187                 ndr_print_WERROR(ndr, "result", r->out.result);
20188                 ndr->depth--;
20189         }
20190         ndr->depth--;
20191 }
20192
20193 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20194 {
20195         if (flags & NDR_IN) {
20196                 if (r->in.handle == NULL) {
20197                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20198                 }
20199                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20204                 if (r->in.buffer) {
20205                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20206                 }
20207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20208         }
20209         if (flags & NDR_OUT) {
20210                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20211                 if (r->out.info) {
20212                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20213                 }
20214                 if (r->out.needed == NULL) {
20215                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20216                 }
20217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20218                 if (r->out.count == NULL) {
20219                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20220                 }
20221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20222                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20223         }
20224         return NDR_ERR_SUCCESS;
20225 }
20226
20227 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20228 {
20229         uint32_t _ptr_buffer;
20230         uint32_t _ptr_info;
20231         TALLOC_CTX *_mem_save_handle_0;
20232         TALLOC_CTX *_mem_save_buffer_0;
20233         TALLOC_CTX *_mem_save_info_0;
20234         TALLOC_CTX *_mem_save_needed_0;
20235         TALLOC_CTX *_mem_save_count_0;
20236         if (flags & NDR_IN) {
20237                 ZERO_STRUCT(r->out);
20238
20239                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20240                         NDR_PULL_ALLOC(ndr, r->in.handle);
20241                 }
20242                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20243                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20244                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20245                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20250                 if (_ptr_buffer) {
20251                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20252                 } else {
20253                         r->in.buffer = NULL;
20254                 }
20255                 if (r->in.buffer) {
20256                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20257                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20258                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20259                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20260                 }
20261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20262                 NDR_PULL_ALLOC(ndr, r->out.needed);
20263                 ZERO_STRUCTP(r->out.needed);
20264                 NDR_PULL_ALLOC(ndr, r->out.count);
20265                 ZERO_STRUCTP(r->out.count);
20266         }
20267         if (flags & NDR_OUT) {
20268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20269                 if (_ptr_info) {
20270                         NDR_PULL_ALLOC(ndr, r->out.info);
20271                 } else {
20272                         r->out.info = NULL;
20273                 }
20274                 if (r->out.info) {
20275                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20276                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20277                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20279                 }
20280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20281                         NDR_PULL_ALLOC(ndr, r->out.needed);
20282                 }
20283                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20284                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20288                         NDR_PULL_ALLOC(ndr, r->out.count);
20289                 }
20290                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20291                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20294                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20295         }
20296         return NDR_ERR_SUCCESS;
20297 }
20298
20299 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20300 {
20301         uint32_t cntr_info_0;
20302         if (flags & NDR_IN) {
20303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20305         }
20306         if (flags & NDR_OUT) {
20307                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20308                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20309                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20310                 }
20311                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20312                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20313                 }
20314         }
20315         return NDR_ERR_SUCCESS;
20316 }
20317
20318 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20319 {
20320         uint32_t cntr_info_0;
20321         TALLOC_CTX *_mem_save_info_0;
20322         if (flags & NDR_IN) {
20323                 ZERO_STRUCT(r->out);
20324
20325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20327         }
20328         if (flags & NDR_OUT) {
20329                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20330                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20332                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20333                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20334                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20335                 }
20336                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20337                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20338                 }
20339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20340         }
20341         return NDR_ERR_SUCCESS;
20342 }
20343
20344 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20345 {
20346         uint32_t cntr_info_2;
20347         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20348         ndr->depth++;
20349         if (flags & NDR_SET_VALUES) {
20350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20351         }
20352         if (flags & NDR_IN) {
20353                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20354                 ndr->depth++;
20355                 ndr_print_ptr(ndr, "handle", r->in.handle);
20356                 ndr->depth++;
20357                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20358                 ndr->depth--;
20359                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20360                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20361                 ndr_print_uint32(ndr, "level", r->in.level);
20362                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20363                 ndr->depth++;
20364                 if (r->in.buffer) {
20365                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20366                 }
20367                 ndr->depth--;
20368                 ndr_print_uint32(ndr, "offered", r->in.offered);
20369                 ndr->depth--;
20370         }
20371         if (flags & NDR_OUT) {
20372                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20373                 ndr->depth++;
20374                 ndr_print_ptr(ndr, "count", r->out.count);
20375                 ndr->depth++;
20376                 ndr_print_uint32(ndr, "count", *r->out.count);
20377                 ndr->depth--;
20378                 ndr_print_ptr(ndr, "info", r->out.info);
20379                 ndr->depth++;
20380                 ndr_print_ptr(ndr, "info", *r->out.info);
20381                 ndr->depth++;
20382                 if (*r->out.info) {
20383                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20384                         ndr->depth++;
20385                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20386                                 char *idx_2=NULL;
20387                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20388                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20389                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20390                                         free(idx_2);
20391                                 }
20392                         }
20393                         ndr->depth--;
20394                 }
20395                 ndr->depth--;
20396                 ndr->depth--;
20397                 ndr_print_ptr(ndr, "needed", r->out.needed);
20398                 ndr->depth++;
20399                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20400                 ndr->depth--;
20401                 ndr_print_WERROR(ndr, "result", r->out.result);
20402                 ndr->depth--;
20403         }
20404         ndr->depth--;
20405 }
20406
20407 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20408 {
20409         if (flags & NDR_IN) {
20410                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20411                 if (r->in.server) {
20412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20413                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20414                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20416                 }
20417                 if (r->in.info_ctr == NULL) {
20418                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20419                 }
20420                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20421                 if (r->in.devmode_ctr == NULL) {
20422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20423                 }
20424                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20425                 if (r->in.secdesc_ctr == NULL) {
20426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20427                 }
20428                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20429         }
20430         if (flags & NDR_OUT) {
20431                 if (r->out.handle == NULL) {
20432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20433                 }
20434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20435                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20436         }
20437         return NDR_ERR_SUCCESS;
20438 }
20439
20440 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20441 {
20442         uint32_t _ptr_server;
20443         TALLOC_CTX *_mem_save_server_0;
20444         TALLOC_CTX *_mem_save_info_ctr_0;
20445         TALLOC_CTX *_mem_save_devmode_ctr_0;
20446         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20447         TALLOC_CTX *_mem_save_handle_0;
20448         if (flags & NDR_IN) {
20449                 ZERO_STRUCT(r->out);
20450
20451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20452                 if (_ptr_server) {
20453                         NDR_PULL_ALLOC(ndr, r->in.server);
20454                 } else {
20455                         r->in.server = NULL;
20456                 }
20457                 if (r->in.server) {
20458                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20459                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20460                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20461                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20462                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20463                                 return 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));
20464                         }
20465                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20466                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20467                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20468                 }
20469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20470                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20471                 }
20472                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20473                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20474                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20477                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20478                 }
20479                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20480                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20481                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20484                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20485                 }
20486                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20487                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20488                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20490                 NDR_PULL_ALLOC(ndr, r->out.handle);
20491                 ZERO_STRUCTP(r->out.handle);
20492         }
20493         if (flags & NDR_OUT) {
20494                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20495                         NDR_PULL_ALLOC(ndr, r->out.handle);
20496                 }
20497                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20498                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20499                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20501                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20502         }
20503         return NDR_ERR_SUCCESS;
20504 }
20505
20506 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20507 {
20508         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20509         ndr->depth++;
20510         if (flags & NDR_SET_VALUES) {
20511                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20512         }
20513         if (flags & NDR_IN) {
20514                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20515                 ndr->depth++;
20516                 ndr_print_ptr(ndr, "server", r->in.server);
20517                 ndr->depth++;
20518                 if (r->in.server) {
20519                         ndr_print_string(ndr, "server", r->in.server);
20520                 }
20521                 ndr->depth--;
20522                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20523                 ndr->depth++;
20524                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20525                 ndr->depth--;
20526                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20527                 ndr->depth++;
20528                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20529                 ndr->depth--;
20530                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20531                 ndr->depth++;
20532                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20533                 ndr->depth--;
20534                 ndr->depth--;
20535         }
20536         if (flags & NDR_OUT) {
20537                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
20538                 ndr->depth++;
20539                 ndr_print_ptr(ndr, "handle", r->out.handle);
20540                 ndr->depth++;
20541                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20542                 ndr->depth--;
20543                 ndr_print_WERROR(ndr, "result", r->out.result);
20544                 ndr->depth--;
20545         }
20546         ndr->depth--;
20547 }
20548
20549 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
20550 {
20551         if (flags & NDR_IN) {
20552                 if (r->in.handle == NULL) {
20553                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20554                 }
20555                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20556         }
20557         if (flags & NDR_OUT) {
20558                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20559         }
20560         return NDR_ERR_SUCCESS;
20561 }
20562
20563 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
20564 {
20565         TALLOC_CTX *_mem_save_handle_0;
20566         if (flags & NDR_IN) {
20567                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20568                         NDR_PULL_ALLOC(ndr, r->in.handle);
20569                 }
20570                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20571                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20572                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20573                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20574         }
20575         if (flags & NDR_OUT) {
20576                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20577         }
20578         return NDR_ERR_SUCCESS;
20579 }
20580
20581 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
20582 {
20583         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
20584         ndr->depth++;
20585         if (flags & NDR_SET_VALUES) {
20586                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20587         }
20588         if (flags & NDR_IN) {
20589                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
20590                 ndr->depth++;
20591                 ndr_print_ptr(ndr, "handle", r->in.handle);
20592                 ndr->depth++;
20593                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20594                 ndr->depth--;
20595                 ndr->depth--;
20596         }
20597         if (flags & NDR_OUT) {
20598                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
20599                 ndr->depth++;
20600                 ndr_print_WERROR(ndr, "result", r->out.result);
20601                 ndr->depth--;
20602         }
20603         ndr->depth--;
20604 }
20605
20606 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
20607 {
20608         if (flags & NDR_IN) {
20609                 if (r->in.handle == NULL) {
20610                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20611                 }
20612                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20613                 if (r->in.info_ctr == NULL) {
20614                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20615                 }
20616                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20617                 if (r->in.devmode_ctr == NULL) {
20618                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20619                 }
20620                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20621                 if (r->in.secdesc_ctr == NULL) {
20622                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20623                 }
20624                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20625                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
20626         }
20627         if (flags & NDR_OUT) {
20628                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20629         }
20630         return NDR_ERR_SUCCESS;
20631 }
20632
20633 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
20634 {
20635         TALLOC_CTX *_mem_save_handle_0;
20636         TALLOC_CTX *_mem_save_info_ctr_0;
20637         TALLOC_CTX *_mem_save_devmode_ctr_0;
20638         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20639         if (flags & NDR_IN) {
20640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20641                         NDR_PULL_ALLOC(ndr, r->in.handle);
20642                 }
20643                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20644                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20645                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20647                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20648                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20649                 }
20650                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20651                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20652                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20653                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20655                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20656                 }
20657                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20659                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20662                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20663                 }
20664                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20665                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20666                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20668                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
20669         }
20670         if (flags & NDR_OUT) {
20671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20672         }
20673         return NDR_ERR_SUCCESS;
20674 }
20675
20676 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
20677 {
20678         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
20679         ndr->depth++;
20680         if (flags & NDR_SET_VALUES) {
20681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20682         }
20683         if (flags & NDR_IN) {
20684                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
20685                 ndr->depth++;
20686                 ndr_print_ptr(ndr, "handle", r->in.handle);
20687                 ndr->depth++;
20688                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20689                 ndr->depth--;
20690                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20691                 ndr->depth++;
20692                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20693                 ndr->depth--;
20694                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20695                 ndr->depth++;
20696                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20697                 ndr->depth--;
20698                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20699                 ndr->depth++;
20700                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20701                 ndr->depth--;
20702                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
20703                 ndr->depth--;
20704         }
20705         if (flags & NDR_OUT) {
20706                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
20707                 ndr->depth++;
20708                 ndr_print_WERROR(ndr, "result", r->out.result);
20709                 ndr->depth--;
20710         }
20711         ndr->depth--;
20712 }
20713
20714 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
20715 {
20716         if (flags & NDR_IN) {
20717                 if (r->in.handle == NULL) {
20718                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20719                 }
20720                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20723                 if (r->in.buffer) {
20724                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20725                 }
20726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20727         }
20728         if (flags & NDR_OUT) {
20729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20730                 if (r->out.info) {
20731                         {
20732                                 struct ndr_push *_ndr_info;
20733                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20734                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20735                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20736                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20737                         }
20738                 }
20739                 if (r->out.needed == NULL) {
20740                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20741                 }
20742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20743                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20744         }
20745         return NDR_ERR_SUCCESS;
20746 }
20747
20748 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
20749 {
20750         uint32_t _ptr_buffer;
20751         uint32_t _ptr_info;
20752         TALLOC_CTX *_mem_save_handle_0;
20753         TALLOC_CTX *_mem_save_buffer_0;
20754         TALLOC_CTX *_mem_save_info_0;
20755         TALLOC_CTX *_mem_save_needed_0;
20756         if (flags & NDR_IN) {
20757                 ZERO_STRUCT(r->out);
20758
20759                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20760                         NDR_PULL_ALLOC(ndr, r->in.handle);
20761                 }
20762                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20763                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20764                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20765                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20768                 if (_ptr_buffer) {
20769                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20770                 } else {
20771                         r->in.buffer = NULL;
20772                 }
20773                 if (r->in.buffer) {
20774                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20775                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20776                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20778                 }
20779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20780                 NDR_PULL_ALLOC(ndr, r->out.needed);
20781                 ZERO_STRUCTP(r->out.needed);
20782         }
20783         if (flags & NDR_OUT) {
20784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20785                 if (_ptr_info) {
20786                         NDR_PULL_ALLOC(ndr, r->out.info);
20787                 } else {
20788                         r->out.info = NULL;
20789                 }
20790                 if (r->out.info) {
20791                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20792                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20793                         {
20794                                 struct ndr_pull *_ndr_info;
20795                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20796                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20797                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20798                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20799                         }
20800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20801                 }
20802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20803                         NDR_PULL_ALLOC(ndr, r->out.needed);
20804                 }
20805                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20806                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20809                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20810         }
20811         return NDR_ERR_SUCCESS;
20812 }
20813
20814 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
20815 {
20816         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
20817         ndr->depth++;
20818         if (flags & NDR_SET_VALUES) {
20819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20820         }
20821         if (flags & NDR_IN) {
20822                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
20823                 ndr->depth++;
20824                 ndr_print_ptr(ndr, "handle", r->in.handle);
20825                 ndr->depth++;
20826                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20827                 ndr->depth--;
20828                 ndr_print_uint32(ndr, "level", r->in.level);
20829                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20830                 ndr->depth++;
20831                 if (r->in.buffer) {
20832                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20833                 }
20834                 ndr->depth--;
20835                 ndr_print_uint32(ndr, "offered", r->in.offered);
20836                 ndr->depth--;
20837         }
20838         if (flags & NDR_OUT) {
20839                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
20840                 ndr->depth++;
20841                 ndr_print_ptr(ndr, "info", r->out.info);
20842                 ndr->depth++;
20843                 if (r->out.info) {
20844                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20845                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
20846                 }
20847                 ndr->depth--;
20848                 ndr_print_ptr(ndr, "needed", r->out.needed);
20849                 ndr->depth++;
20850                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20851                 ndr->depth--;
20852                 ndr_print_WERROR(ndr, "result", r->out.result);
20853                 ndr->depth--;
20854         }
20855         ndr->depth--;
20856 }
20857
20858 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
20859 {
20860         if (flags & NDR_IN) {
20861                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20862                 if (r->in.servername) {
20863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20867                 }
20868                 if (r->in.info_ctr == NULL) {
20869                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20870                 }
20871                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20872         }
20873         if (flags & NDR_OUT) {
20874                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20875         }
20876         return NDR_ERR_SUCCESS;
20877 }
20878
20879 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
20880 {
20881         uint32_t _ptr_servername;
20882         TALLOC_CTX *_mem_save_servername_0;
20883         TALLOC_CTX *_mem_save_info_ctr_0;
20884         if (flags & NDR_IN) {
20885                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20886                 if (_ptr_servername) {
20887                         NDR_PULL_ALLOC(ndr, r->in.servername);
20888                 } else {
20889                         r->in.servername = NULL;
20890                 }
20891                 if (r->in.servername) {
20892                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20893                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20894                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20895                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20896                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20897                                 return 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));
20898                         }
20899                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20900                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20902                 }
20903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20904                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20905                 }
20906                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20907                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20908                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20910         }
20911         if (flags & NDR_OUT) {
20912                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20913         }
20914         return NDR_ERR_SUCCESS;
20915 }
20916
20917 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
20918 {
20919         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
20920         ndr->depth++;
20921         if (flags & NDR_SET_VALUES) {
20922                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20923         }
20924         if (flags & NDR_IN) {
20925                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
20926                 ndr->depth++;
20927                 ndr_print_ptr(ndr, "servername", r->in.servername);
20928                 ndr->depth++;
20929                 if (r->in.servername) {
20930                         ndr_print_string(ndr, "servername", r->in.servername);
20931                 }
20932                 ndr->depth--;
20933                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20934                 ndr->depth++;
20935                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20936                 ndr->depth--;
20937                 ndr->depth--;
20938         }
20939         if (flags & NDR_OUT) {
20940                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20941                 ndr->depth++;
20942                 ndr_print_WERROR(ndr, "result", r->out.result);
20943                 ndr->depth--;
20944         }
20945         ndr->depth--;
20946 }
20947
20948 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20949 {
20950         if (flags & NDR_IN) {
20951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20952                 if (r->in.server) {
20953                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20957                 }
20958                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20959                 if (r->in.environment) {
20960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20961                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20962                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20964                 }
20965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20967                 if (r->in.buffer) {
20968                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20969                 }
20970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20971         }
20972         if (flags & NDR_OUT) {
20973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20974                 if (r->out.info) {
20975                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20976                 }
20977                 if (r->out.needed == NULL) {
20978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20979                 }
20980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20981                 if (r->out.count == NULL) {
20982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20983                 }
20984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20985                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20986         }
20987         return NDR_ERR_SUCCESS;
20988 }
20989
20990 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20991 {
20992         uint32_t _ptr_server;
20993         uint32_t _ptr_environment;
20994         uint32_t _ptr_buffer;
20995         uint32_t _ptr_info;
20996         TALLOC_CTX *_mem_save_server_0;
20997         TALLOC_CTX *_mem_save_environment_0;
20998         TALLOC_CTX *_mem_save_buffer_0;
20999         TALLOC_CTX *_mem_save_info_0;
21000         TALLOC_CTX *_mem_save_needed_0;
21001         TALLOC_CTX *_mem_save_count_0;
21002         if (flags & NDR_IN) {
21003                 ZERO_STRUCT(r->out);
21004
21005                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21006                 if (_ptr_server) {
21007                         NDR_PULL_ALLOC(ndr, r->in.server);
21008                 } else {
21009                         r->in.server = NULL;
21010                 }
21011                 if (r->in.server) {
21012                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21013                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21014                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21015                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21016                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21017                                 return 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));
21018                         }
21019                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21020                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21022                 }
21023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21024                 if (_ptr_environment) {
21025                         NDR_PULL_ALLOC(ndr, r->in.environment);
21026                 } else {
21027                         r->in.environment = NULL;
21028                 }
21029                 if (r->in.environment) {
21030                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21031                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21033                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21034                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21035                                 return 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));
21036                         }
21037                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21040                 }
21041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21043                 if (_ptr_buffer) {
21044                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21045                 } else {
21046                         r->in.buffer = NULL;
21047                 }
21048                 if (r->in.buffer) {
21049                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21050                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21051                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21053                 }
21054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21055                 NDR_PULL_ALLOC(ndr, r->out.needed);
21056                 ZERO_STRUCTP(r->out.needed);
21057                 NDR_PULL_ALLOC(ndr, r->out.count);
21058                 ZERO_STRUCTP(r->out.count);
21059         }
21060         if (flags & NDR_OUT) {
21061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21062                 if (_ptr_info) {
21063                         NDR_PULL_ALLOC(ndr, r->out.info);
21064                 } else {
21065                         r->out.info = NULL;
21066                 }
21067                 if (r->out.info) {
21068                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21069                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21070                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21072                 }
21073                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21074                         NDR_PULL_ALLOC(ndr, r->out.needed);
21075                 }
21076                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21077                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21079                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21080                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21081                         NDR_PULL_ALLOC(ndr, r->out.count);
21082                 }
21083                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21084                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21086                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21087                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21088         }
21089         return NDR_ERR_SUCCESS;
21090 }
21091
21092 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21093 {
21094         uint32_t cntr_info_0;
21095         if (flags & NDR_IN) {
21096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21098         }
21099         if (flags & NDR_OUT) {
21100                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21101                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21102                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21103                 }
21104                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21105                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21106                 }
21107         }
21108         return NDR_ERR_SUCCESS;
21109 }
21110
21111 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21112 {
21113         uint32_t cntr_info_0;
21114         TALLOC_CTX *_mem_save_info_0;
21115         if (flags & NDR_IN) {
21116                 ZERO_STRUCT(r->out);
21117
21118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21120         }
21121         if (flags & NDR_OUT) {
21122                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21123                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21124                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21125                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21126                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21127                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21128                 }
21129                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21130                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21131                 }
21132                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21133         }
21134         return NDR_ERR_SUCCESS;
21135 }
21136
21137 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21138 {
21139         uint32_t cntr_info_2;
21140         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21141         ndr->depth++;
21142         if (flags & NDR_SET_VALUES) {
21143                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21144         }
21145         if (flags & NDR_IN) {
21146                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21147                 ndr->depth++;
21148                 ndr_print_ptr(ndr, "server", r->in.server);
21149                 ndr->depth++;
21150                 if (r->in.server) {
21151                         ndr_print_string(ndr, "server", r->in.server);
21152                 }
21153                 ndr->depth--;
21154                 ndr_print_ptr(ndr, "environment", r->in.environment);
21155                 ndr->depth++;
21156                 if (r->in.environment) {
21157                         ndr_print_string(ndr, "environment", r->in.environment);
21158                 }
21159                 ndr->depth--;
21160                 ndr_print_uint32(ndr, "level", r->in.level);
21161                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21162                 ndr->depth++;
21163                 if (r->in.buffer) {
21164                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21165                 }
21166                 ndr->depth--;
21167                 ndr_print_uint32(ndr, "offered", r->in.offered);
21168                 ndr->depth--;
21169         }
21170         if (flags & NDR_OUT) {
21171                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21172                 ndr->depth++;
21173                 ndr_print_ptr(ndr, "count", r->out.count);
21174                 ndr->depth++;
21175                 ndr_print_uint32(ndr, "count", *r->out.count);
21176                 ndr->depth--;
21177                 ndr_print_ptr(ndr, "info", r->out.info);
21178                 ndr->depth++;
21179                 ndr_print_ptr(ndr, "info", *r->out.info);
21180                 ndr->depth++;
21181                 if (*r->out.info) {
21182                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21183                         ndr->depth++;
21184                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21185                                 char *idx_2=NULL;
21186                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21187                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21188                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21189                                         free(idx_2);
21190                                 }
21191                         }
21192                         ndr->depth--;
21193                 }
21194                 ndr->depth--;
21195                 ndr->depth--;
21196                 ndr_print_ptr(ndr, "needed", r->out.needed);
21197                 ndr->depth++;
21198                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21199                 ndr->depth--;
21200                 ndr_print_WERROR(ndr, "result", r->out.result);
21201                 ndr->depth--;
21202         }
21203         ndr->depth--;
21204 }
21205
21206 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21207 {
21208         if (flags & NDR_IN) {
21209                 if (r->in.handle == NULL) {
21210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21211                 }
21212                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21213                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21214                 if (r->in.architecture) {
21215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21218                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21219                 }
21220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21221                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21222                 if (r->in.buffer) {
21223                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21224                 }
21225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21226         }
21227         if (flags & NDR_OUT) {
21228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21229                 if (r->out.info) {
21230                         {
21231                                 struct ndr_push *_ndr_info;
21232                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21233                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21234                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21235                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21236                         }
21237                 }
21238                 if (r->out.needed == NULL) {
21239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21240                 }
21241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21243         }
21244         return NDR_ERR_SUCCESS;
21245 }
21246
21247 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
21248 {
21249         uint32_t _ptr_architecture;
21250         uint32_t _ptr_buffer;
21251         uint32_t _ptr_info;
21252         TALLOC_CTX *_mem_save_handle_0;
21253         TALLOC_CTX *_mem_save_architecture_0;
21254         TALLOC_CTX *_mem_save_buffer_0;
21255         TALLOC_CTX *_mem_save_info_0;
21256         TALLOC_CTX *_mem_save_needed_0;
21257         if (flags & NDR_IN) {
21258                 ZERO_STRUCT(r->out);
21259
21260                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21261                         NDR_PULL_ALLOC(ndr, r->in.handle);
21262                 }
21263                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21264                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21265                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21266                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21268                 if (_ptr_architecture) {
21269                         NDR_PULL_ALLOC(ndr, r->in.architecture);
21270                 } else {
21271                         r->in.architecture = NULL;
21272                 }
21273                 if (r->in.architecture) {
21274                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21275                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21276                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21277                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21278                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21279                                 return 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));
21280                         }
21281                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21282                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21284                 }
21285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21287                 if (_ptr_buffer) {
21288                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21289                 } else {
21290                         r->in.buffer = NULL;
21291                 }
21292                 if (r->in.buffer) {
21293                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21295                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21297                 }
21298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21299                 NDR_PULL_ALLOC(ndr, r->out.needed);
21300                 ZERO_STRUCTP(r->out.needed);
21301         }
21302         if (flags & NDR_OUT) {
21303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21304                 if (_ptr_info) {
21305                         NDR_PULL_ALLOC(ndr, r->out.info);
21306                 } else {
21307                         r->out.info = NULL;
21308                 }
21309                 if (r->out.info) {
21310                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21311                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21312                         {
21313                                 struct ndr_pull *_ndr_info;
21314                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21315                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21316                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21317                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21318                         }
21319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21320                 }
21321                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21322                         NDR_PULL_ALLOC(ndr, r->out.needed);
21323                 }
21324                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21325                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21327                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21328                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21329         }
21330         return NDR_ERR_SUCCESS;
21331 }
21332
21333 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21334 {
21335         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21336         ndr->depth++;
21337         if (flags & NDR_SET_VALUES) {
21338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21339         }
21340         if (flags & NDR_IN) {
21341                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21342                 ndr->depth++;
21343                 ndr_print_ptr(ndr, "handle", r->in.handle);
21344                 ndr->depth++;
21345                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21346                 ndr->depth--;
21347                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21348                 ndr->depth++;
21349                 if (r->in.architecture) {
21350                         ndr_print_string(ndr, "architecture", r->in.architecture);
21351                 }
21352                 ndr->depth--;
21353                 ndr_print_uint32(ndr, "level", r->in.level);
21354                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21355                 ndr->depth++;
21356                 if (r->in.buffer) {
21357                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21358                 }
21359                 ndr->depth--;
21360                 ndr_print_uint32(ndr, "offered", r->in.offered);
21361                 ndr->depth--;
21362         }
21363         if (flags & NDR_OUT) {
21364                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
21365                 ndr->depth++;
21366                 ndr_print_ptr(ndr, "info", r->out.info);
21367                 ndr->depth++;
21368                 if (r->out.info) {
21369                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21370                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
21371                 }
21372                 ndr->depth--;
21373                 ndr_print_ptr(ndr, "needed", r->out.needed);
21374                 ndr->depth++;
21375                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21376                 ndr->depth--;
21377                 ndr_print_WERROR(ndr, "result", r->out.result);
21378                 ndr->depth--;
21379         }
21380         ndr->depth--;
21381 }
21382
21383 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21384 {
21385         if (flags & NDR_IN) {
21386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21387                 if (r->in.server) {
21388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21389                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21390                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21391                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21392                 }
21393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21394                 if (r->in.environment) {
21395                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21396                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21399                 }
21400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21402                 if (r->in.buffer) {
21403                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21404                 }
21405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21406         }
21407         if (flags & NDR_OUT) {
21408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21409                 if (r->out.info) {
21410                         {
21411                                 struct ndr_push *_ndr_info;
21412                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21413                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21414                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21415                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21416                         }
21417                 }
21418                 if (r->out.needed == NULL) {
21419                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21420                 }
21421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21422                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21423         }
21424         return NDR_ERR_SUCCESS;
21425 }
21426
21427 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
21428 {
21429         uint32_t _ptr_server;
21430         uint32_t _ptr_environment;
21431         uint32_t _ptr_buffer;
21432         uint32_t _ptr_info;
21433         TALLOC_CTX *_mem_save_server_0;
21434         TALLOC_CTX *_mem_save_environment_0;
21435         TALLOC_CTX *_mem_save_buffer_0;
21436         TALLOC_CTX *_mem_save_info_0;
21437         TALLOC_CTX *_mem_save_needed_0;
21438         if (flags & NDR_IN) {
21439                 ZERO_STRUCT(r->out);
21440
21441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21442                 if (_ptr_server) {
21443                         NDR_PULL_ALLOC(ndr, r->in.server);
21444                 } else {
21445                         r->in.server = NULL;
21446                 }
21447                 if (r->in.server) {
21448                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21449                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21450                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21451                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21452                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21453                                 return 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));
21454                         }
21455                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21456                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21457                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21458                 }
21459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21460                 if (_ptr_environment) {
21461                         NDR_PULL_ALLOC(ndr, r->in.environment);
21462                 } else {
21463                         r->in.environment = NULL;
21464                 }
21465                 if (r->in.environment) {
21466                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21467                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21470                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21471                                 return 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));
21472                         }
21473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21474                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21476                 }
21477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21479                 if (_ptr_buffer) {
21480                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21481                 } else {
21482                         r->in.buffer = NULL;
21483                 }
21484                 if (r->in.buffer) {
21485                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21486                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21487                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21489                 }
21490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21491                 NDR_PULL_ALLOC(ndr, r->out.needed);
21492                 ZERO_STRUCTP(r->out.needed);
21493         }
21494         if (flags & NDR_OUT) {
21495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21496                 if (_ptr_info) {
21497                         NDR_PULL_ALLOC(ndr, r->out.info);
21498                 } else {
21499                         r->out.info = NULL;
21500                 }
21501                 if (r->out.info) {
21502                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21503                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21504                         {
21505                                 struct ndr_pull *_ndr_info;
21506                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21507                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21508                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21509                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21510                         }
21511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21512                 }
21513                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21514                         NDR_PULL_ALLOC(ndr, r->out.needed);
21515                 }
21516                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21519                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21521         }
21522         return NDR_ERR_SUCCESS;
21523 }
21524
21525 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21526 {
21527         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
21528         ndr->depth++;
21529         if (flags & NDR_SET_VALUES) {
21530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21531         }
21532         if (flags & NDR_IN) {
21533                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
21534                 ndr->depth++;
21535                 ndr_print_ptr(ndr, "server", r->in.server);
21536                 ndr->depth++;
21537                 if (r->in.server) {
21538                         ndr_print_string(ndr, "server", r->in.server);
21539                 }
21540                 ndr->depth--;
21541                 ndr_print_ptr(ndr, "environment", r->in.environment);
21542                 ndr->depth++;
21543                 if (r->in.environment) {
21544                         ndr_print_string(ndr, "environment", r->in.environment);
21545                 }
21546                 ndr->depth--;
21547                 ndr_print_uint32(ndr, "level", r->in.level);
21548                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21549                 ndr->depth++;
21550                 if (r->in.buffer) {
21551                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21552                 }
21553                 ndr->depth--;
21554                 ndr_print_uint32(ndr, "offered", r->in.offered);
21555                 ndr->depth--;
21556         }
21557         if (flags & NDR_OUT) {
21558                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
21559                 ndr->depth++;
21560                 ndr_print_ptr(ndr, "info", r->out.info);
21561                 ndr->depth++;
21562                 if (r->out.info) {
21563                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21564                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
21565                 }
21566                 ndr->depth--;
21567                 ndr_print_ptr(ndr, "needed", r->out.needed);
21568                 ndr->depth++;
21569                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21570                 ndr->depth--;
21571                 ndr_print_WERROR(ndr, "result", r->out.result);
21572                 ndr->depth--;
21573         }
21574         ndr->depth--;
21575 }
21576
21577 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
21578 {
21579         if (flags & NDR_IN) {
21580                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21581                 if (r->in.server) {
21582                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21583                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21584                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21585                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21586                 }
21587                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21588                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21589                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21590                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21591                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21592                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21593                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21594                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21595         }
21596         if (flags & NDR_OUT) {
21597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21598         }
21599         return NDR_ERR_SUCCESS;
21600 }
21601
21602 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
21603 {
21604         uint32_t _ptr_server;
21605         TALLOC_CTX *_mem_save_server_0;
21606         if (flags & NDR_IN) {
21607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21608                 if (_ptr_server) {
21609                         NDR_PULL_ALLOC(ndr, r->in.server);
21610                 } else {
21611                         r->in.server = NULL;
21612                 }
21613                 if (r->in.server) {
21614                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21615                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21617                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21618                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21619                                 return 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));
21620                         }
21621                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21622                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21624                 }
21625                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21626                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21627                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21628                         return 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));
21629                 }
21630                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21631                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21632                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
21633                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
21634                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
21635                         return 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));
21636                 }
21637                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
21638                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
21639         }
21640         if (flags & NDR_OUT) {
21641                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21642         }
21643         return NDR_ERR_SUCCESS;
21644 }
21645
21646 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
21647 {
21648         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
21649         ndr->depth++;
21650         if (flags & NDR_SET_VALUES) {
21651                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21652         }
21653         if (flags & NDR_IN) {
21654                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
21655                 ndr->depth++;
21656                 ndr_print_ptr(ndr, "server", r->in.server);
21657                 ndr->depth++;
21658                 if (r->in.server) {
21659                         ndr_print_string(ndr, "server", r->in.server);
21660                 }
21661                 ndr->depth--;
21662                 ndr_print_string(ndr, "architecture", r->in.architecture);
21663                 ndr_print_string(ndr, "driver", r->in.driver);
21664                 ndr->depth--;
21665         }
21666         if (flags & NDR_OUT) {
21667                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
21668                 ndr->depth++;
21669                 ndr_print_WERROR(ndr, "result", r->out.result);
21670                 ndr->depth--;
21671         }
21672         ndr->depth--;
21673 }
21674
21675 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
21676 {
21677         if (flags & NDR_IN) {
21678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21679                 if (r->in.server) {
21680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21681                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21682                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21683                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21684                 }
21685                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21686                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21687                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21688                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21689                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21690                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21691                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21692                 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));
21693                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21694                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21695                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21696                 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));
21697         }
21698         if (flags & NDR_OUT) {
21699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21700         }
21701         return NDR_ERR_SUCCESS;
21702 }
21703
21704 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
21705 {
21706         uint32_t _ptr_server;
21707         TALLOC_CTX *_mem_save_server_0;
21708         if (flags & NDR_IN) {
21709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21710                 if (_ptr_server) {
21711                         NDR_PULL_ALLOC(ndr, r->in.server);
21712                 } else {
21713                         r->in.server = NULL;
21714                 }
21715                 if (r->in.server) {
21716                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21717                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21718                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21719                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21720                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21721                                 return 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));
21722                         }
21723                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21724                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21726                 }
21727                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21728                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21729                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21730                         return 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));
21731                 }
21732                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21733                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21734                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
21735                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
21736                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
21737                         return 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));
21738                 }
21739                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
21740                 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));
21741                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
21742                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
21743                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
21744                         return 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));
21745                 }
21746                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
21747                 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));
21748         }
21749         if (flags & NDR_OUT) {
21750                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21751         }
21752         return NDR_ERR_SUCCESS;
21753 }
21754
21755 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
21756 {
21757         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
21758         ndr->depth++;
21759         if (flags & NDR_SET_VALUES) {
21760                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21761         }
21762         if (flags & NDR_IN) {
21763                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
21764                 ndr->depth++;
21765                 ndr_print_ptr(ndr, "server", r->in.server);
21766                 ndr->depth++;
21767                 if (r->in.server) {
21768                         ndr_print_string(ndr, "server", r->in.server);
21769                 }
21770                 ndr->depth--;
21771                 ndr_print_string(ndr, "architecture", r->in.architecture);
21772                 ndr_print_string(ndr, "path_name", r->in.path_name);
21773                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
21774                 ndr->depth--;
21775         }
21776         if (flags & NDR_OUT) {
21777                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
21778                 ndr->depth++;
21779                 ndr_print_WERROR(ndr, "result", r->out.result);
21780                 ndr->depth--;
21781         }
21782         ndr->depth--;
21783 }
21784
21785 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
21786 {
21787         if (flags & NDR_IN) {
21788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21789                 if (r->in.servername) {
21790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21793                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21794                 }
21795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21796                 if (r->in.environment) {
21797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21799                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21800                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21801                 }
21802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21804                 if (r->in.buffer) {
21805                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21806                 }
21807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21808         }
21809         if (flags & NDR_OUT) {
21810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21811                 if (r->out.info) {
21812                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21813                 }
21814                 if (r->out.needed == NULL) {
21815                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21816                 }
21817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21818                 if (r->out.count == NULL) {
21819                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21820                 }
21821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21822                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21823         }
21824         return NDR_ERR_SUCCESS;
21825 }
21826
21827 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
21828 {
21829         uint32_t _ptr_servername;
21830         uint32_t _ptr_environment;
21831         uint32_t _ptr_buffer;
21832         uint32_t _ptr_info;
21833         TALLOC_CTX *_mem_save_servername_0;
21834         TALLOC_CTX *_mem_save_environment_0;
21835         TALLOC_CTX *_mem_save_buffer_0;
21836         TALLOC_CTX *_mem_save_info_0;
21837         TALLOC_CTX *_mem_save_needed_0;
21838         TALLOC_CTX *_mem_save_count_0;
21839         if (flags & NDR_IN) {
21840                 ZERO_STRUCT(r->out);
21841
21842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21843                 if (_ptr_servername) {
21844                         NDR_PULL_ALLOC(ndr, r->in.servername);
21845                 } else {
21846                         r->in.servername = NULL;
21847                 }
21848                 if (r->in.servername) {
21849                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21853                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21854                                 return 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));
21855                         }
21856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21857                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21859                 }
21860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21861                 if (_ptr_environment) {
21862                         NDR_PULL_ALLOC(ndr, r->in.environment);
21863                 } else {
21864                         r->in.environment = NULL;
21865                 }
21866                 if (r->in.environment) {
21867                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21868                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21869                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21870                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21871                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21872                                 return 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));
21873                         }
21874                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21875                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21877                 }
21878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21880                 if (_ptr_buffer) {
21881                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21882                 } else {
21883                         r->in.buffer = NULL;
21884                 }
21885                 if (r->in.buffer) {
21886                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21887                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21888                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21890                 }
21891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21892                 NDR_PULL_ALLOC(ndr, r->out.needed);
21893                 ZERO_STRUCTP(r->out.needed);
21894                 NDR_PULL_ALLOC(ndr, r->out.count);
21895                 ZERO_STRUCTP(r->out.count);
21896         }
21897         if (flags & NDR_OUT) {
21898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21899                 if (_ptr_info) {
21900                         NDR_PULL_ALLOC(ndr, r->out.info);
21901                 } else {
21902                         r->out.info = NULL;
21903                 }
21904                 if (r->out.info) {
21905                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21906                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21907                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21909                 }
21910                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21911                         NDR_PULL_ALLOC(ndr, r->out.needed);
21912                 }
21913                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21914                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21916                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21917                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21918                         NDR_PULL_ALLOC(ndr, r->out.count);
21919                 }
21920                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21921                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21924                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21925         }
21926         return NDR_ERR_SUCCESS;
21927 }
21928
21929 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
21930 {
21931         uint32_t cntr_info_0;
21932         if (flags & NDR_IN) {
21933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21935         }
21936         if (flags & NDR_OUT) {
21937                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21938                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21939                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21940                 }
21941                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21942                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21943                 }
21944         }
21945         return NDR_ERR_SUCCESS;
21946 }
21947
21948 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
21949 {
21950         uint32_t cntr_info_0;
21951         TALLOC_CTX *_mem_save_info_0;
21952         if (flags & NDR_IN) {
21953                 ZERO_STRUCT(r->out);
21954
21955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21957         }
21958         if (flags & NDR_OUT) {
21959                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21960                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21961                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21962                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21963                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21964                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21965                 }
21966                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21967                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21968                 }
21969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21970         }
21971         return NDR_ERR_SUCCESS;
21972 }
21973
21974 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
21975 {
21976         uint32_t cntr_info_2;
21977         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
21978         ndr->depth++;
21979         if (flags & NDR_SET_VALUES) {
21980                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21981         }
21982         if (flags & NDR_IN) {
21983                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
21984                 ndr->depth++;
21985                 ndr_print_ptr(ndr, "servername", r->in.servername);
21986                 ndr->depth++;
21987                 if (r->in.servername) {
21988                         ndr_print_string(ndr, "servername", r->in.servername);
21989                 }
21990                 ndr->depth--;
21991                 ndr_print_ptr(ndr, "environment", r->in.environment);
21992                 ndr->depth++;
21993                 if (r->in.environment) {
21994                         ndr_print_string(ndr, "environment", r->in.environment);
21995                 }
21996                 ndr->depth--;
21997                 ndr_print_uint32(ndr, "level", r->in.level);
21998                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21999                 ndr->depth++;
22000                 if (r->in.buffer) {
22001                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22002                 }
22003                 ndr->depth--;
22004                 ndr_print_uint32(ndr, "offered", r->in.offered);
22005                 ndr->depth--;
22006         }
22007         if (flags & NDR_OUT) {
22008                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22009                 ndr->depth++;
22010                 ndr_print_ptr(ndr, "count", r->out.count);
22011                 ndr->depth++;
22012                 ndr_print_uint32(ndr, "count", *r->out.count);
22013                 ndr->depth--;
22014                 ndr_print_ptr(ndr, "info", r->out.info);
22015                 ndr->depth++;
22016                 ndr_print_ptr(ndr, "info", *r->out.info);
22017                 ndr->depth++;
22018                 if (*r->out.info) {
22019                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22020                         ndr->depth++;
22021                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22022                                 char *idx_2=NULL;
22023                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22024                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22025                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22026                                         free(idx_2);
22027                                 }
22028                         }
22029                         ndr->depth--;
22030                 }
22031                 ndr->depth--;
22032                 ndr->depth--;
22033                 ndr_print_ptr(ndr, "needed", r->out.needed);
22034                 ndr->depth++;
22035                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22036                 ndr->depth--;
22037                 ndr_print_WERROR(ndr, "result", r->out.result);
22038                 ndr->depth--;
22039         }
22040         ndr->depth--;
22041 }
22042
22043 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22044 {
22045         if (flags & NDR_IN) {
22046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22047                 if (r->in.server) {
22048                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22051                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22052                 }
22053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22054                 if (r->in.environment) {
22055                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22056                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22058                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22059                 }
22060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22062                 if (r->in.buffer) {
22063                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22064                 }
22065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22066         }
22067         if (flags & NDR_OUT) {
22068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22069                 if (r->out.info) {
22070                         {
22071                                 struct ndr_push *_ndr_info;
22072                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22073                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22074                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22075                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22076                         }
22077                 }
22078                 if (r->out.needed == NULL) {
22079                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22080                 }
22081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22082                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22083         }
22084         return NDR_ERR_SUCCESS;
22085 }
22086
22087 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22088 {
22089         uint32_t _ptr_server;
22090         uint32_t _ptr_environment;
22091         uint32_t _ptr_buffer;
22092         uint32_t _ptr_info;
22093         TALLOC_CTX *_mem_save_server_0;
22094         TALLOC_CTX *_mem_save_environment_0;
22095         TALLOC_CTX *_mem_save_buffer_0;
22096         TALLOC_CTX *_mem_save_info_0;
22097         TALLOC_CTX *_mem_save_needed_0;
22098         if (flags & NDR_IN) {
22099                 ZERO_STRUCT(r->out);
22100
22101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22102                 if (_ptr_server) {
22103                         NDR_PULL_ALLOC(ndr, r->in.server);
22104                 } else {
22105                         r->in.server = NULL;
22106                 }
22107                 if (r->in.server) {
22108                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22109                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22110                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22111                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22112                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22113                                 return 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));
22114                         }
22115                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22116                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22118                 }
22119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22120                 if (_ptr_environment) {
22121                         NDR_PULL_ALLOC(ndr, r->in.environment);
22122                 } else {
22123                         r->in.environment = NULL;
22124                 }
22125                 if (r->in.environment) {
22126                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22127                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22130                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22131                                 return 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));
22132                         }
22133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22136                 }
22137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22139                 if (_ptr_buffer) {
22140                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22141                 } else {
22142                         r->in.buffer = NULL;
22143                 }
22144                 if (r->in.buffer) {
22145                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22146                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22147                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22149                 }
22150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22151                 NDR_PULL_ALLOC(ndr, r->out.needed);
22152                 ZERO_STRUCTP(r->out.needed);
22153         }
22154         if (flags & NDR_OUT) {
22155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22156                 if (_ptr_info) {
22157                         NDR_PULL_ALLOC(ndr, r->out.info);
22158                 } else {
22159                         r->out.info = NULL;
22160                 }
22161                 if (r->out.info) {
22162                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22163                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22164                         {
22165                                 struct ndr_pull *_ndr_info;
22166                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22167                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22168                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22169                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22170                         }
22171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22172                 }
22173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22174                         NDR_PULL_ALLOC(ndr, r->out.needed);
22175                 }
22176                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22177                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22179                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22181         }
22182         return NDR_ERR_SUCCESS;
22183 }
22184
22185 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22186 {
22187         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22188         ndr->depth++;
22189         if (flags & NDR_SET_VALUES) {
22190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22191         }
22192         if (flags & NDR_IN) {
22193                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22194                 ndr->depth++;
22195                 ndr_print_ptr(ndr, "server", r->in.server);
22196                 ndr->depth++;
22197                 if (r->in.server) {
22198                         ndr_print_string(ndr, "server", r->in.server);
22199                 }
22200                 ndr->depth--;
22201                 ndr_print_ptr(ndr, "environment", r->in.environment);
22202                 ndr->depth++;
22203                 if (r->in.environment) {
22204                         ndr_print_string(ndr, "environment", r->in.environment);
22205                 }
22206                 ndr->depth--;
22207                 ndr_print_uint32(ndr, "level", r->in.level);
22208                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22209                 ndr->depth++;
22210                 if (r->in.buffer) {
22211                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22212                 }
22213                 ndr->depth--;
22214                 ndr_print_uint32(ndr, "offered", r->in.offered);
22215                 ndr->depth--;
22216         }
22217         if (flags & NDR_OUT) {
22218                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22219                 ndr->depth++;
22220                 ndr_print_ptr(ndr, "info", r->out.info);
22221                 ndr->depth++;
22222                 if (r->out.info) {
22223                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22224                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
22225                 }
22226                 ndr->depth--;
22227                 ndr_print_ptr(ndr, "needed", r->out.needed);
22228                 ndr->depth++;
22229                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22230                 ndr->depth--;
22231                 ndr_print_WERROR(ndr, "result", r->out.result);
22232                 ndr->depth--;
22233         }
22234         ndr->depth--;
22235 }
22236
22237 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
22238 {
22239         if (flags & NDR_IN) {
22240                 if (r->in.handle == NULL) {
22241                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22242                 }
22243                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22245                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22246                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22247         }
22248         if (flags & NDR_OUT) {
22249                 if (r->out.job_id == NULL) {
22250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22251                 }
22252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
22253                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22254         }
22255         return NDR_ERR_SUCCESS;
22256 }
22257
22258 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22259 {
22260         TALLOC_CTX *_mem_save_handle_0;
22261         TALLOC_CTX *_mem_save_job_id_0;
22262         if (flags & NDR_IN) {
22263                 ZERO_STRUCT(r->out);
22264
22265                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22266                         NDR_PULL_ALLOC(ndr, r->in.handle);
22267                 }
22268                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22269                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22270                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22273                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22274                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22275                 NDR_PULL_ALLOC(ndr, r->out.job_id);
22276                 ZERO_STRUCTP(r->out.job_id);
22277         }
22278         if (flags & NDR_OUT) {
22279                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22280                         NDR_PULL_ALLOC(ndr, r->out.job_id);
22281                 }
22282                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22283                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22285                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22286                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22287         }
22288         return NDR_ERR_SUCCESS;
22289 }
22290
22291 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22292 {
22293         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22294         ndr->depth++;
22295         if (flags & NDR_SET_VALUES) {
22296                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22297         }
22298         if (flags & NDR_IN) {
22299                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22300                 ndr->depth++;
22301                 ndr_print_ptr(ndr, "handle", r->in.handle);
22302                 ndr->depth++;
22303                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22304                 ndr->depth--;
22305                 ndr_print_uint32(ndr, "level", r->in.level);
22306                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22307                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22308                 ndr->depth--;
22309         }
22310         if (flags & NDR_OUT) {
22311                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22312                 ndr->depth++;
22313                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
22314                 ndr->depth++;
22315                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22316                 ndr->depth--;
22317                 ndr_print_WERROR(ndr, "result", r->out.result);
22318                 ndr->depth--;
22319         }
22320         ndr->depth--;
22321 }
22322
22323 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22324 {
22325         if (flags & NDR_IN) {
22326                 if (r->in.handle == NULL) {
22327                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22328                 }
22329                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22330         }
22331         if (flags & NDR_OUT) {
22332                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22333         }
22334         return NDR_ERR_SUCCESS;
22335 }
22336
22337 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22338 {
22339         TALLOC_CTX *_mem_save_handle_0;
22340         if (flags & NDR_IN) {
22341                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22342                         NDR_PULL_ALLOC(ndr, r->in.handle);
22343                 }
22344                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22345                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22346                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22347                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22348         }
22349         if (flags & NDR_OUT) {
22350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22351         }
22352         return NDR_ERR_SUCCESS;
22353 }
22354
22355 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22356 {
22357         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22358         ndr->depth++;
22359         if (flags & NDR_SET_VALUES) {
22360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22361         }
22362         if (flags & NDR_IN) {
22363                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22364                 ndr->depth++;
22365                 ndr_print_ptr(ndr, "handle", r->in.handle);
22366                 ndr->depth++;
22367                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22368                 ndr->depth--;
22369                 ndr->depth--;
22370         }
22371         if (flags & NDR_OUT) {
22372                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
22373                 ndr->depth++;
22374                 ndr_print_WERROR(ndr, "result", r->out.result);
22375                 ndr->depth--;
22376         }
22377         ndr->depth--;
22378 }
22379
22380 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
22381 {
22382         if (flags & NDR_IN) {
22383                 if (r->in.handle == NULL) {
22384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22385                 }
22386                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22387                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
22389         }
22390         if (flags & NDR_OUT) {
22391                 if (r->out.num_written == NULL) {
22392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22393                 }
22394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
22395                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22396         }
22397         return NDR_ERR_SUCCESS;
22398 }
22399
22400 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
22401 {
22402         TALLOC_CTX *_mem_save_handle_0;
22403         TALLOC_CTX *_mem_save_num_written_0;
22404         if (flags & NDR_IN) {
22405                 ZERO_STRUCT(r->out);
22406
22407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22408                         NDR_PULL_ALLOC(ndr, r->in.handle);
22409                 }
22410                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22411                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22412                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22414                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
22415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
22416                 NDR_PULL_ALLOC(ndr, r->out.num_written);
22417                 ZERO_STRUCTP(r->out.num_written);
22418         }
22419         if (flags & NDR_OUT) {
22420                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22421                         NDR_PULL_ALLOC(ndr, r->out.num_written);
22422                 }
22423                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
22424                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
22425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
22426                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
22427                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22428         }
22429         return NDR_ERR_SUCCESS;
22430 }
22431
22432 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
22433 {
22434         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
22435         ndr->depth++;
22436         if (flags & NDR_SET_VALUES) {
22437                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22438         }
22439         if (flags & NDR_IN) {
22440                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
22441                 ndr->depth++;
22442                 ndr_print_ptr(ndr, "handle", r->in.handle);
22443                 ndr->depth++;
22444                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22445                 ndr->depth--;
22446                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
22447                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
22448                 ndr->depth--;
22449         }
22450         if (flags & NDR_OUT) {
22451                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
22452                 ndr->depth++;
22453                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
22454                 ndr->depth++;
22455                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
22456                 ndr->depth--;
22457                 ndr_print_WERROR(ndr, "result", r->out.result);
22458                 ndr->depth--;
22459         }
22460         ndr->depth--;
22461 }
22462
22463 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22464 {
22465         if (flags & NDR_IN) {
22466                 if (r->in.handle == NULL) {
22467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22468                 }
22469                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22470         }
22471         if (flags & NDR_OUT) {
22472                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22473         }
22474         return NDR_ERR_SUCCESS;
22475 }
22476
22477 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22478 {
22479         TALLOC_CTX *_mem_save_handle_0;
22480         if (flags & NDR_IN) {
22481                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22482                         NDR_PULL_ALLOC(ndr, r->in.handle);
22483                 }
22484                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22485                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22486                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22487                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22488         }
22489         if (flags & NDR_OUT) {
22490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22491         }
22492         return NDR_ERR_SUCCESS;
22493 }
22494
22495 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22496 {
22497         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22498         ndr->depth++;
22499         if (flags & NDR_SET_VALUES) {
22500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22501         }
22502         if (flags & NDR_IN) {
22503                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22504                 ndr->depth++;
22505                 ndr_print_ptr(ndr, "handle", r->in.handle);
22506                 ndr->depth++;
22507                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22508                 ndr->depth--;
22509                 ndr->depth--;
22510         }
22511         if (flags & NDR_OUT) {
22512                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22513                 ndr->depth++;
22514                 ndr_print_WERROR(ndr, "result", r->out.result);
22515                 ndr->depth--;
22516         }
22517         ndr->depth--;
22518 }
22519
22520 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22521 {
22522         if (flags & NDR_IN) {
22523                 if (r->in.handle == NULL) {
22524                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22525                 }
22526                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22527         }
22528         if (flags & NDR_OUT) {
22529                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22530         }
22531         return NDR_ERR_SUCCESS;
22532 }
22533
22534 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
22535 {
22536         TALLOC_CTX *_mem_save_handle_0;
22537         if (flags & NDR_IN) {
22538                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22539                         NDR_PULL_ALLOC(ndr, r->in.handle);
22540                 }
22541                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22542                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22543                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22544                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22545         }
22546         if (flags & NDR_OUT) {
22547                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22548         }
22549         return NDR_ERR_SUCCESS;
22550 }
22551
22552 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
22553 {
22554         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
22555         ndr->depth++;
22556         if (flags & NDR_SET_VALUES) {
22557                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22558         }
22559         if (flags & NDR_IN) {
22560                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
22561                 ndr->depth++;
22562                 ndr_print_ptr(ndr, "handle", r->in.handle);
22563                 ndr->depth++;
22564                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22565                 ndr->depth--;
22566                 ndr->depth--;
22567         }
22568         if (flags & NDR_OUT) {
22569                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
22570                 ndr->depth++;
22571                 ndr_print_WERROR(ndr, "result", r->out.result);
22572                 ndr->depth--;
22573         }
22574         ndr->depth--;
22575 }
22576
22577 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
22578 {
22579         if (flags & NDR_IN) {
22580                 if (r->in.handle == NULL) {
22581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22582                 }
22583                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22585         }
22586         if (flags & NDR_OUT) {
22587                 if (r->out.data == NULL) {
22588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22589                 }
22590                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
22591                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
22592                 if (r->out._data_size == NULL) {
22593                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22594                 }
22595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
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_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
22602 {
22603         TALLOC_CTX *_mem_save_handle_0;
22604         TALLOC_CTX *_mem_save__data_size_0;
22605         if (flags & NDR_IN) {
22606                 ZERO_STRUCT(r->out);
22607
22608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22609                         NDR_PULL_ALLOC(ndr, r->in.handle);
22610                 }
22611                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22612                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22613                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
22616                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
22617                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
22618                 NDR_PULL_ALLOC(ndr, r->out._data_size);
22619                 ZERO_STRUCTP(r->out._data_size);
22620         }
22621         if (flags & NDR_OUT) {
22622                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
22623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22624                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
22625                 }
22626                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
22627                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22628                         NDR_PULL_ALLOC(ndr, r->out._data_size);
22629                 }
22630                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
22631                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
22632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
22633                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
22634                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22635                 if (r->out.data) {
22636                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
22637                 }
22638         }
22639         return NDR_ERR_SUCCESS;
22640 }
22641
22642 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
22643 {
22644         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
22645         ndr->depth++;
22646         if (flags & NDR_SET_VALUES) {
22647                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22648         }
22649         if (flags & NDR_IN) {
22650                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
22651                 ndr->depth++;
22652                 ndr_print_ptr(ndr, "handle", r->in.handle);
22653                 ndr->depth++;
22654                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22655                 ndr->depth--;
22656                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
22657                 ndr->depth--;
22658         }
22659         if (flags & NDR_OUT) {
22660                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
22661                 ndr->depth++;
22662                 ndr_print_ptr(ndr, "data", r->out.data);
22663                 ndr->depth++;
22664                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
22665                 ndr->depth--;
22666                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
22667                 ndr->depth++;
22668                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
22669                 ndr->depth--;
22670                 ndr_print_WERROR(ndr, "result", r->out.result);
22671                 ndr->depth--;
22672         }
22673         ndr->depth--;
22674 }
22675
22676 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
22677 {
22678         if (flags & NDR_IN) {
22679                 if (r->in.handle == NULL) {
22680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22681                 }
22682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22683         }
22684         if (flags & NDR_OUT) {
22685                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22686         }
22687         return NDR_ERR_SUCCESS;
22688 }
22689
22690 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
22691 {
22692         TALLOC_CTX *_mem_save_handle_0;
22693         if (flags & NDR_IN) {
22694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22695                         NDR_PULL_ALLOC(ndr, r->in.handle);
22696                 }
22697                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22698                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22699                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22701         }
22702         if (flags & NDR_OUT) {
22703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22704         }
22705         return NDR_ERR_SUCCESS;
22706 }
22707
22708 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
22709 {
22710         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
22711         ndr->depth++;
22712         if (flags & NDR_SET_VALUES) {
22713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22714         }
22715         if (flags & NDR_IN) {
22716                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
22717                 ndr->depth++;
22718                 ndr_print_ptr(ndr, "handle", r->in.handle);
22719                 ndr->depth++;
22720                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22721                 ndr->depth--;
22722                 ndr->depth--;
22723         }
22724         if (flags & NDR_OUT) {
22725                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
22726                 ndr->depth++;
22727                 ndr_print_WERROR(ndr, "result", r->out.result);
22728                 ndr->depth--;
22729         }
22730         ndr->depth--;
22731 }
22732
22733 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
22734 {
22735         if (flags & NDR_IN) {
22736                 if (r->in.handle == NULL) {
22737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22738                 }
22739                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22741                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22742                 if (r->in.buffer) {
22743                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
22744                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
22745                 }
22746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22747         }
22748         if (flags & NDR_OUT) {
22749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
22750                 if (r->out.buffer) {
22751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
22752                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22753                 }
22754                 if (r->out.needed == NULL) {
22755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22756                 }
22757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22759         }
22760         return NDR_ERR_SUCCESS;
22761 }
22762
22763 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
22764 {
22765         uint32_t _ptr_buffer;
22766         TALLOC_CTX *_mem_save_handle_0;
22767         TALLOC_CTX *_mem_save_buffer_0;
22768         TALLOC_CTX *_mem_save_needed_0;
22769         if (flags & NDR_IN) {
22770                 ZERO_STRUCT(r->out);
22771
22772                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22773                         NDR_PULL_ALLOC(ndr, r->in.handle);
22774                 }
22775                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22776                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22777                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22778                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22780                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22781                 if (_ptr_buffer) {
22782                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22783                 } else {
22784                         r->in.buffer = NULL;
22785                 }
22786                 if (r->in.buffer) {
22787                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22788                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22790                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22791                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22793                 }
22794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22795                 NDR_PULL_ALLOC(ndr, r->out.needed);
22796                 ZERO_STRUCTP(r->out.needed);
22797                 if (r->in.buffer) {
22798                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
22799                 }
22800         }
22801         if (flags & NDR_OUT) {
22802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22803                 if (_ptr_buffer) {
22804                         NDR_PULL_ALLOC(ndr, r->out.buffer);
22805                 } else {
22806                         r->out.buffer = NULL;
22807                 }
22808                 if (r->out.buffer) {
22809                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22810                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
22811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22812                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22813                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22815                 }
22816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22817                         NDR_PULL_ALLOC(ndr, r->out.needed);
22818                 }
22819                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22820                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22823                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22824                 if (r->out.buffer) {
22825                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22826                 }
22827         }
22828         return NDR_ERR_SUCCESS;
22829 }
22830
22831 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
22832 {
22833         ndr_print_struct(ndr, name, "spoolss_AddJob");
22834         ndr->depth++;
22835         if (flags & NDR_SET_VALUES) {
22836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22837         }
22838         if (flags & NDR_IN) {
22839                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
22840                 ndr->depth++;
22841                 ndr_print_ptr(ndr, "handle", r->in.handle);
22842                 ndr->depth++;
22843                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22844                 ndr->depth--;
22845                 ndr_print_uint32(ndr, "level", r->in.level);
22846                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22847                 ndr->depth++;
22848                 if (r->in.buffer) {
22849                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
22850                 }
22851                 ndr->depth--;
22852                 ndr_print_uint32(ndr, "offered", r->in.offered);
22853                 ndr->depth--;
22854         }
22855         if (flags & NDR_OUT) {
22856                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
22857                 ndr->depth++;
22858                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22859                 ndr->depth++;
22860                 if (r->out.buffer) {
22861                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22862                 }
22863                 ndr->depth--;
22864                 ndr_print_ptr(ndr, "needed", r->out.needed);
22865                 ndr->depth++;
22866                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22867                 ndr->depth--;
22868                 ndr_print_WERROR(ndr, "result", r->out.result);
22869                 ndr->depth--;
22870         }
22871         ndr->depth--;
22872 }
22873
22874 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
22875 {
22876         if (flags & NDR_IN) {
22877                 if (r->in.handle == NULL) {
22878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22879                 }
22880                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
22882         }
22883         if (flags & NDR_OUT) {
22884                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22885         }
22886         return NDR_ERR_SUCCESS;
22887 }
22888
22889 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
22890 {
22891         TALLOC_CTX *_mem_save_handle_0;
22892         if (flags & NDR_IN) {
22893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22894                         NDR_PULL_ALLOC(ndr, r->in.handle);
22895                 }
22896                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22897                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22898                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
22901         }
22902         if (flags & NDR_OUT) {
22903                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22904         }
22905         return NDR_ERR_SUCCESS;
22906 }
22907
22908 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
22909 {
22910         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
22911         ndr->depth++;
22912         if (flags & NDR_SET_VALUES) {
22913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22914         }
22915         if (flags & NDR_IN) {
22916                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
22917                 ndr->depth++;
22918                 ndr_print_ptr(ndr, "handle", r->in.handle);
22919                 ndr->depth++;
22920                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22921                 ndr->depth--;
22922                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
22923                 ndr->depth--;
22924         }
22925         if (flags & NDR_OUT) {
22926                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
22927                 ndr->depth++;
22928                 ndr_print_WERROR(ndr, "result", r->out.result);
22929                 ndr->depth--;
22930         }
22931         ndr->depth--;
22932 }
22933
22934 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
22935 {
22936         if (flags & NDR_IN) {
22937                 if (r->in.handle == NULL) {
22938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22939                 }
22940                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22941                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22942                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22943                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22944                 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));
22945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22946         }
22947         if (flags & NDR_OUT) {
22948                 if (r->out.type == NULL) {
22949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22950                 }
22951                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
22952                 if (r->out.data == NULL) {
22953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22954                 }
22955                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
22956                 if (r->out.needed == NULL) {
22957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22958                 }
22959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22960                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22961         }
22962         return NDR_ERR_SUCCESS;
22963 }
22964
22965 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
22966 {
22967         TALLOC_CTX *_mem_save_handle_0;
22968         TALLOC_CTX *_mem_save_type_0;
22969         TALLOC_CTX *_mem_save_data_0;
22970         TALLOC_CTX *_mem_save_needed_0;
22971         if (flags & NDR_IN) {
22972                 ZERO_STRUCT(r->out);
22973
22974                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22975                         NDR_PULL_ALLOC(ndr, r->in.handle);
22976                 }
22977                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22978                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22979                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22981                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22982                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22983                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22984                         return 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));
22985                 }
22986                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22987                 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));
22988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22989                 NDR_PULL_ALLOC(ndr, r->out.type);
22990                 ZERO_STRUCTP(r->out.type);
22991                 NDR_PULL_ALLOC(ndr, r->out.data);
22992                 ZERO_STRUCTP(r->out.data);
22993                 NDR_PULL_ALLOC(ndr, r->out.needed);
22994                 ZERO_STRUCTP(r->out.needed);
22995         }
22996         if (flags & NDR_OUT) {
22997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22998                         NDR_PULL_ALLOC(ndr, r->out.type);
22999                 }
23000                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23001                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23002                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23005                         NDR_PULL_ALLOC(ndr, r->out.data);
23006                 }
23007                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23008                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23009                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23012                         NDR_PULL_ALLOC(ndr, r->out.needed);
23013                 }
23014                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23015                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23018                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23019         }
23020         return NDR_ERR_SUCCESS;
23021 }
23022
23023 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23024 {
23025         if (flags & NDR_IN) {
23026                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23027         }
23028         if (flags & NDR_OUT) {
23029                 if (r->out.data == NULL) {
23030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23031                 }
23032                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23033                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23034         }
23035         return NDR_ERR_SUCCESS;
23036 }
23037
23038 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23039 {
23040         TALLOC_CTX *_mem_save_data_0;
23041         if (flags & NDR_IN) {
23042                 ZERO_STRUCT(r->out);
23043
23044                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23045                 NDR_PULL_ALLOC(ndr, r->out.data);
23046                 ZERO_STRUCTP(r->out.data);
23047         }
23048         if (flags & NDR_OUT) {
23049                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23050                         NDR_PULL_ALLOC(ndr, r->out.data);
23051                 }
23052                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23053                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23054                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23055                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23056                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23057         }
23058         return NDR_ERR_SUCCESS;
23059 }
23060
23061 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23062 {
23063         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23064         ndr->depth++;
23065         if (flags & NDR_SET_VALUES) {
23066                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23067         }
23068         if (flags & NDR_IN) {
23069                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23070                 ndr->depth++;
23071                 ndr_print_ptr(ndr, "handle", r->in.handle);
23072                 ndr->depth++;
23073                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23074                 ndr->depth--;
23075                 ndr_print_string(ndr, "value_name", r->in.value_name);
23076                 ndr_print_uint32(ndr, "offered", r->in.offered);
23077                 ndr->depth--;
23078         }
23079         if (flags & NDR_OUT) {
23080                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23081                 ndr->depth++;
23082                 ndr_print_ptr(ndr, "type", r->out.type);
23083                 ndr->depth++;
23084                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23085                 ndr->depth--;
23086                 ndr_print_ptr(ndr, "data", r->out.data);
23087                 ndr->depth++;
23088                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23089                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23090                 ndr->depth--;
23091                 ndr_print_ptr(ndr, "needed", r->out.needed);
23092                 ndr->depth++;
23093                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23094                 ndr->depth--;
23095                 ndr_print_WERROR(ndr, "result", r->out.result);
23096                 ndr->depth--;
23097         }
23098         ndr->depth--;
23099 }
23100
23101 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23102 {
23103         if (flags & NDR_IN) {
23104                 if (r->in.handle == NULL) {
23105                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23106                 }
23107                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23108                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23109                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23110                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23111                 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));
23112                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23113                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
23115         }
23116         if (flags & NDR_OUT) {
23117                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23118         }
23119         return NDR_ERR_SUCCESS;
23120 }
23121
23122 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
23123 {
23124         if (flags & NDR_IN) {
23125                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23126         }
23127         if (flags & NDR_OUT) {
23128                 if (r->out.data == NULL) {
23129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23130                 }
23131                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23132                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23133         }
23134         return NDR_ERR_SUCCESS;
23135 }
23136
23137 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23138 {
23139         TALLOC_CTX *_mem_save_handle_0;
23140         if (flags & NDR_IN) {
23141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23142                         NDR_PULL_ALLOC(ndr, r->in.handle);
23143                 }
23144                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23145                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23146                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23148                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23149                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23150                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23151                         return 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));
23152                 }
23153                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23154                 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));
23155                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23156                 {
23157                         struct ndr_pull *_ndr_data;
23158                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
23159                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
23160                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
23161                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
23162                 }
23163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
23164         }
23165         if (flags & NDR_OUT) {
23166                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23167         }
23168         return NDR_ERR_SUCCESS;
23169 }
23170
23171 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23172 {
23173         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
23174         ndr->depth++;
23175         if (flags & NDR_SET_VALUES) {
23176                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23177         }
23178         if (flags & NDR_IN) {
23179                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
23180                 ndr->depth++;
23181                 ndr_print_ptr(ndr, "handle", r->in.handle);
23182                 ndr->depth++;
23183                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23184                 ndr->depth--;
23185                 ndr_print_string(ndr, "value_name", r->in.value_name);
23186                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23187                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
23188                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
23189                 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);
23190                 ndr->depth--;
23191         }
23192         if (flags & NDR_OUT) {
23193                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23194                 ndr->depth++;
23195                 ndr_print_WERROR(ndr, "result", r->out.result);
23196                 ndr->depth--;
23197         }
23198         ndr->depth--;
23199 }
23200
23201 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23202 {
23203         if (flags & NDR_IN) {
23204         }
23205         if (flags & NDR_OUT) {
23206                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23207         }
23208         return NDR_ERR_SUCCESS;
23209 }
23210
23211 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23212 {
23213         if (flags & NDR_IN) {
23214         }
23215         if (flags & NDR_OUT) {
23216                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23217         }
23218         return NDR_ERR_SUCCESS;
23219 }
23220
23221 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
23222 {
23223         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
23224         ndr->depth++;
23225         if (flags & NDR_SET_VALUES) {
23226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23227         }
23228         if (flags & NDR_IN) {
23229                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
23230                 ndr->depth++;
23231                 ndr->depth--;
23232         }
23233         if (flags & NDR_OUT) {
23234                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
23235                 ndr->depth++;
23236                 ndr_print_WERROR(ndr, "result", r->out.result);
23237                 ndr->depth--;
23238         }
23239         ndr->depth--;
23240 }
23241
23242 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
23243 {
23244         if (flags & NDR_IN) {
23245                 if (r->in.handle == NULL) {
23246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23247                 }
23248                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23249         }
23250         if (flags & NDR_OUT) {
23251                 if (r->out.handle == NULL) {
23252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23253                 }
23254                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23255                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23256         }
23257         return NDR_ERR_SUCCESS;
23258 }
23259
23260 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23261 {
23262         TALLOC_CTX *_mem_save_handle_0;
23263         if (flags & NDR_IN) {
23264                 ZERO_STRUCT(r->out);
23265
23266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23267                         NDR_PULL_ALLOC(ndr, r->in.handle);
23268                 }
23269                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23271                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23273                 NDR_PULL_ALLOC(ndr, r->out.handle);
23274                 *r->out.handle = *r->in.handle;
23275         }
23276         if (flags & NDR_OUT) {
23277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23278                         NDR_PULL_ALLOC(ndr, r->out.handle);
23279                 }
23280                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23281                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23282                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23284                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23285         }
23286         return NDR_ERR_SUCCESS;
23287 }
23288
23289 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23290 {
23291         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23292         ndr->depth++;
23293         if (flags & NDR_SET_VALUES) {
23294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23295         }
23296         if (flags & NDR_IN) {
23297                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23298                 ndr->depth++;
23299                 ndr_print_ptr(ndr, "handle", r->in.handle);
23300                 ndr->depth++;
23301                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23302                 ndr->depth--;
23303                 ndr->depth--;
23304         }
23305         if (flags & NDR_OUT) {
23306                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23307                 ndr->depth++;
23308                 ndr_print_ptr(ndr, "handle", r->out.handle);
23309                 ndr->depth++;
23310                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23311                 ndr->depth--;
23312                 ndr_print_WERROR(ndr, "result", r->out.result);
23313                 ndr->depth--;
23314         }
23315         ndr->depth--;
23316 }
23317
23318 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23319 {
23320         if (flags & NDR_IN) {
23321                 if (r->in.handle == NULL) {
23322                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23323                 }
23324                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23326                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23327                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23328         }
23329         if (flags & NDR_OUT) {
23330                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23331         }
23332         return NDR_ERR_SUCCESS;
23333 }
23334
23335 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23336 {
23337         TALLOC_CTX *_mem_save_handle_0;
23338         if (flags & NDR_IN) {
23339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23340                         NDR_PULL_ALLOC(ndr, r->in.handle);
23341                 }
23342                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23343                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23344                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23347                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23348                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23349         }
23350         if (flags & NDR_OUT) {
23351                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23352         }
23353         return NDR_ERR_SUCCESS;
23354 }
23355
23356 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23357 {
23358         ndr_print_struct(ndr, name, "spoolss_AddForm");
23359         ndr->depth++;
23360         if (flags & NDR_SET_VALUES) {
23361                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23362         }
23363         if (flags & NDR_IN) {
23364                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
23365                 ndr->depth++;
23366                 ndr_print_ptr(ndr, "handle", r->in.handle);
23367                 ndr->depth++;
23368                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23369                 ndr->depth--;
23370                 ndr_print_uint32(ndr, "level", r->in.level);
23371                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23372                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23373                 ndr->depth--;
23374         }
23375         if (flags & NDR_OUT) {
23376                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
23377                 ndr->depth++;
23378                 ndr_print_WERROR(ndr, "result", r->out.result);
23379                 ndr->depth--;
23380         }
23381         ndr->depth--;
23382 }
23383
23384 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
23385 {
23386         if (flags & NDR_IN) {
23387                 if (r->in.handle == NULL) {
23388                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23389                 }
23390                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23391                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23392                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23393                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23394                 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));
23395         }
23396         if (flags & NDR_OUT) {
23397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23398         }
23399         return NDR_ERR_SUCCESS;
23400 }
23401
23402 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
23403 {
23404         TALLOC_CTX *_mem_save_handle_0;
23405         if (flags & NDR_IN) {
23406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23407                         NDR_PULL_ALLOC(ndr, r->in.handle);
23408                 }
23409                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23410                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23411                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23413                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23414                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23415                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23416                         return 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));
23417                 }
23418                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23419                 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));
23420         }
23421         if (flags & NDR_OUT) {
23422                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23423         }
23424         return NDR_ERR_SUCCESS;
23425 }
23426
23427 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
23428 {
23429         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
23430         ndr->depth++;
23431         if (flags & NDR_SET_VALUES) {
23432                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23433         }
23434         if (flags & NDR_IN) {
23435                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
23436                 ndr->depth++;
23437                 ndr_print_ptr(ndr, "handle", r->in.handle);
23438                 ndr->depth++;
23439                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23440                 ndr->depth--;
23441                 ndr_print_string(ndr, "form_name", r->in.form_name);
23442                 ndr->depth--;
23443         }
23444         if (flags & NDR_OUT) {
23445                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
23446                 ndr->depth++;
23447                 ndr_print_WERROR(ndr, "result", r->out.result);
23448                 ndr->depth--;
23449         }
23450         ndr->depth--;
23451 }
23452
23453 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
23454 {
23455         if (flags & NDR_IN) {
23456                 if (r->in.handle == NULL) {
23457                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23458                 }
23459                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23460                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23461                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23462                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23463                 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));
23464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23466                 if (r->in.buffer) {
23467                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23468                 }
23469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23470         }
23471         if (flags & NDR_OUT) {
23472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23473                 if (r->out.info) {
23474                         {
23475                                 struct ndr_push *_ndr_info;
23476                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23477                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23478                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23479                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23480                         }
23481                 }
23482                 if (r->out.needed == NULL) {
23483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23484                 }
23485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23487         }
23488         return NDR_ERR_SUCCESS;
23489 }
23490
23491 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23492 {
23493         uint32_t _ptr_buffer;
23494         uint32_t _ptr_info;
23495         TALLOC_CTX *_mem_save_handle_0;
23496         TALLOC_CTX *_mem_save_buffer_0;
23497         TALLOC_CTX *_mem_save_info_0;
23498         TALLOC_CTX *_mem_save_needed_0;
23499         if (flags & NDR_IN) {
23500                 ZERO_STRUCT(r->out);
23501
23502                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23503                         NDR_PULL_ALLOC(ndr, r->in.handle);
23504                 }
23505                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23506                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23507                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23508                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23509                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23510                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23511                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23512                         return 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));
23513                 }
23514                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23515                 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));
23516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23518                 if (_ptr_buffer) {
23519                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23520                 } else {
23521                         r->in.buffer = NULL;
23522                 }
23523                 if (r->in.buffer) {
23524                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23525                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23526                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23528                 }
23529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23530                 NDR_PULL_ALLOC(ndr, r->out.needed);
23531                 ZERO_STRUCTP(r->out.needed);
23532         }
23533         if (flags & NDR_OUT) {
23534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23535                 if (_ptr_info) {
23536                         NDR_PULL_ALLOC(ndr, r->out.info);
23537                 } else {
23538                         r->out.info = NULL;
23539                 }
23540                 if (r->out.info) {
23541                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23542                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23543                         {
23544                                 struct ndr_pull *_ndr_info;
23545                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23546                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23547                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23548                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23549                         }
23550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23551                 }
23552                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23553                         NDR_PULL_ALLOC(ndr, r->out.needed);
23554                 }
23555                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23556                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23558                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23559                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23560         }
23561         return NDR_ERR_SUCCESS;
23562 }
23563
23564 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23565 {
23566         ndr_print_struct(ndr, name, "spoolss_GetForm");
23567         ndr->depth++;
23568         if (flags & NDR_SET_VALUES) {
23569                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23570         }
23571         if (flags & NDR_IN) {
23572                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
23573                 ndr->depth++;
23574                 ndr_print_ptr(ndr, "handle", r->in.handle);
23575                 ndr->depth++;
23576                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23577                 ndr->depth--;
23578                 ndr_print_string(ndr, "form_name", r->in.form_name);
23579                 ndr_print_uint32(ndr, "level", r->in.level);
23580                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23581                 ndr->depth++;
23582                 if (r->in.buffer) {
23583                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23584                 }
23585                 ndr->depth--;
23586                 ndr_print_uint32(ndr, "offered", r->in.offered);
23587                 ndr->depth--;
23588         }
23589         if (flags & NDR_OUT) {
23590                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
23591                 ndr->depth++;
23592                 ndr_print_ptr(ndr, "info", r->out.info);
23593                 ndr->depth++;
23594                 if (r->out.info) {
23595                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23596                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
23597                 }
23598                 ndr->depth--;
23599                 ndr_print_ptr(ndr, "needed", r->out.needed);
23600                 ndr->depth++;
23601                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23602                 ndr->depth--;
23603                 ndr_print_WERROR(ndr, "result", r->out.result);
23604                 ndr->depth--;
23605         }
23606         ndr->depth--;
23607 }
23608
23609 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
23610 {
23611         if (flags & NDR_IN) {
23612                 if (r->in.handle == NULL) {
23613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23614                 }
23615                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23616                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23617                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23618                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23619                 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));
23620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23621                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23622                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23623         }
23624         if (flags & NDR_OUT) {
23625                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23626         }
23627         return NDR_ERR_SUCCESS;
23628 }
23629
23630 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
23631 {
23632         TALLOC_CTX *_mem_save_handle_0;
23633         if (flags & NDR_IN) {
23634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23635                         NDR_PULL_ALLOC(ndr, r->in.handle);
23636                 }
23637                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23638                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23639                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23641                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23642                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23643                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23644                         return 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));
23645                 }
23646                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23647                 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));
23648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23649                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23650                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23651         }
23652         if (flags & NDR_OUT) {
23653                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23654         }
23655         return NDR_ERR_SUCCESS;
23656 }
23657
23658 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
23659 {
23660         ndr_print_struct(ndr, name, "spoolss_SetForm");
23661         ndr->depth++;
23662         if (flags & NDR_SET_VALUES) {
23663                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23664         }
23665         if (flags & NDR_IN) {
23666                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
23667                 ndr->depth++;
23668                 ndr_print_ptr(ndr, "handle", r->in.handle);
23669                 ndr->depth++;
23670                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23671                 ndr->depth--;
23672                 ndr_print_string(ndr, "form_name", r->in.form_name);
23673                 ndr_print_uint32(ndr, "level", r->in.level);
23674                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23675                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23676                 ndr->depth--;
23677         }
23678         if (flags & NDR_OUT) {
23679                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
23680                 ndr->depth++;
23681                 ndr_print_WERROR(ndr, "result", r->out.result);
23682                 ndr->depth--;
23683         }
23684         ndr->depth--;
23685 }
23686
23687 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
23688 {
23689         if (flags & NDR_IN) {
23690                 if (r->in.handle == NULL) {
23691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23692                 }
23693                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23696                 if (r->in.buffer) {
23697                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23698                 }
23699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23700         }
23701         if (flags & NDR_OUT) {
23702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23703                 if (r->out.info) {
23704                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23705                 }
23706                 if (r->out.needed == NULL) {
23707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23708                 }
23709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23710                 if (r->out.count == NULL) {
23711                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23712                 }
23713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23714                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23715         }
23716         return NDR_ERR_SUCCESS;
23717 }
23718
23719 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
23720 {
23721         uint32_t _ptr_buffer;
23722         uint32_t _ptr_info;
23723         TALLOC_CTX *_mem_save_handle_0;
23724         TALLOC_CTX *_mem_save_buffer_0;
23725         TALLOC_CTX *_mem_save_info_0;
23726         TALLOC_CTX *_mem_save_needed_0;
23727         TALLOC_CTX *_mem_save_count_0;
23728         if (flags & NDR_IN) {
23729                 ZERO_STRUCT(r->out);
23730
23731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23732                         NDR_PULL_ALLOC(ndr, r->in.handle);
23733                 }
23734                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23735                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23740                 if (_ptr_buffer) {
23741                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23742                 } else {
23743                         r->in.buffer = NULL;
23744                 }
23745                 if (r->in.buffer) {
23746                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23747                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23748                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23750                 }
23751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23752                 NDR_PULL_ALLOC(ndr, r->out.needed);
23753                 ZERO_STRUCTP(r->out.needed);
23754                 NDR_PULL_ALLOC(ndr, r->out.count);
23755                 ZERO_STRUCTP(r->out.count);
23756         }
23757         if (flags & NDR_OUT) {
23758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23759                 if (_ptr_info) {
23760                         NDR_PULL_ALLOC(ndr, r->out.info);
23761                 } else {
23762                         r->out.info = NULL;
23763                 }
23764                 if (r->out.info) {
23765                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23766                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23767                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23769                 }
23770                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23771                         NDR_PULL_ALLOC(ndr, r->out.needed);
23772                 }
23773                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23774                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23776                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23778                         NDR_PULL_ALLOC(ndr, r->out.count);
23779                 }
23780                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23781                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23784                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23785         }
23786         return NDR_ERR_SUCCESS;
23787 }
23788
23789 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
23790 {
23791         uint32_t cntr_info_0;
23792         if (flags & NDR_IN) {
23793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23795         }
23796         if (flags & NDR_OUT) {
23797                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23798                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23799                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23800                 }
23801                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23802                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23803                 }
23804         }
23805         return NDR_ERR_SUCCESS;
23806 }
23807
23808 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
23809 {
23810         uint32_t cntr_info_0;
23811         TALLOC_CTX *_mem_save_info_0;
23812         if (flags & NDR_IN) {
23813                 ZERO_STRUCT(r->out);
23814
23815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23817         }
23818         if (flags & NDR_OUT) {
23819                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23820                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23821                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23822                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23823                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23824                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23825                 }
23826                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23827                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23828                 }
23829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23830         }
23831         return NDR_ERR_SUCCESS;
23832 }
23833
23834 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
23835 {
23836         uint32_t cntr_info_2;
23837         ndr_print_struct(ndr, name, "spoolss_EnumForms");
23838         ndr->depth++;
23839         if (flags & NDR_SET_VALUES) {
23840                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23841         }
23842         if (flags & NDR_IN) {
23843                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
23844                 ndr->depth++;
23845                 ndr_print_ptr(ndr, "handle", r->in.handle);
23846                 ndr->depth++;
23847                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23848                 ndr->depth--;
23849                 ndr_print_uint32(ndr, "level", r->in.level);
23850                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23851                 ndr->depth++;
23852                 if (r->in.buffer) {
23853                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23854                 }
23855                 ndr->depth--;
23856                 ndr_print_uint32(ndr, "offered", r->in.offered);
23857                 ndr->depth--;
23858         }
23859         if (flags & NDR_OUT) {
23860                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
23861                 ndr->depth++;
23862                 ndr_print_ptr(ndr, "count", r->out.count);
23863                 ndr->depth++;
23864                 ndr_print_uint32(ndr, "count", *r->out.count);
23865                 ndr->depth--;
23866                 ndr_print_ptr(ndr, "info", r->out.info);
23867                 ndr->depth++;
23868                 ndr_print_ptr(ndr, "info", *r->out.info);
23869                 ndr->depth++;
23870                 if (*r->out.info) {
23871                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23872                         ndr->depth++;
23873                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23874                                 char *idx_2=NULL;
23875                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23876                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23877                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23878                                         free(idx_2);
23879                                 }
23880                         }
23881                         ndr->depth--;
23882                 }
23883                 ndr->depth--;
23884                 ndr->depth--;
23885                 ndr_print_ptr(ndr, "needed", r->out.needed);
23886                 ndr->depth++;
23887                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23888                 ndr->depth--;
23889                 ndr_print_WERROR(ndr, "result", r->out.result);
23890                 ndr->depth--;
23891         }
23892         ndr->depth--;
23893 }
23894
23895 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
23896 {
23897         if (flags & NDR_IN) {
23898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23899                 if (r->in.servername) {
23900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23904                 }
23905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23907                 if (r->in.buffer) {
23908                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23909                 }
23910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23911         }
23912         if (flags & NDR_OUT) {
23913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23914                 if (r->out.info) {
23915                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23916                 }
23917                 if (r->out.needed == NULL) {
23918                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23919                 }
23920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23921                 if (r->out.count == NULL) {
23922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23923                 }
23924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23926         }
23927         return NDR_ERR_SUCCESS;
23928 }
23929
23930 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
23931 {
23932         uint32_t _ptr_servername;
23933         uint32_t _ptr_buffer;
23934         uint32_t _ptr_info;
23935         TALLOC_CTX *_mem_save_servername_0;
23936         TALLOC_CTX *_mem_save_buffer_0;
23937         TALLOC_CTX *_mem_save_info_0;
23938         TALLOC_CTX *_mem_save_needed_0;
23939         TALLOC_CTX *_mem_save_count_0;
23940         if (flags & NDR_IN) {
23941                 ZERO_STRUCT(r->out);
23942
23943                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23944                 if (_ptr_servername) {
23945                         NDR_PULL_ALLOC(ndr, r->in.servername);
23946                 } else {
23947                         r->in.servername = NULL;
23948                 }
23949                 if (r->in.servername) {
23950                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23951                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23954                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23955                                 return 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));
23956                         }
23957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23960                 }
23961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23963                 if (_ptr_buffer) {
23964                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23965                 } else {
23966                         r->in.buffer = NULL;
23967                 }
23968                 if (r->in.buffer) {
23969                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23970                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23971                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23972                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23973                 }
23974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23975                 NDR_PULL_ALLOC(ndr, r->out.needed);
23976                 ZERO_STRUCTP(r->out.needed);
23977                 NDR_PULL_ALLOC(ndr, r->out.count);
23978                 ZERO_STRUCTP(r->out.count);
23979         }
23980         if (flags & NDR_OUT) {
23981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23982                 if (_ptr_info) {
23983                         NDR_PULL_ALLOC(ndr, r->out.info);
23984                 } else {
23985                         r->out.info = NULL;
23986                 }
23987                 if (r->out.info) {
23988                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23989                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23990                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23992                 }
23993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23994                         NDR_PULL_ALLOC(ndr, r->out.needed);
23995                 }
23996                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23997                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23999                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24000                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24001                         NDR_PULL_ALLOC(ndr, r->out.count);
24002                 }
24003                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24004                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24006                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24007                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24008         }
24009         return NDR_ERR_SUCCESS;
24010 }
24011
24012 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24013 {
24014         uint32_t cntr_info_0;
24015         if (flags & NDR_IN) {
24016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24018         }
24019         if (flags & NDR_OUT) {
24020                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24021                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24022                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24023                 }
24024                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24025                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24026                 }
24027         }
24028         return NDR_ERR_SUCCESS;
24029 }
24030
24031 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24032 {
24033         uint32_t cntr_info_0;
24034         TALLOC_CTX *_mem_save_info_0;
24035         if (flags & NDR_IN) {
24036                 ZERO_STRUCT(r->out);
24037
24038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24040         }
24041         if (flags & NDR_OUT) {
24042                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24043                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24044                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24045                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24046                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24047                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24048                 }
24049                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24050                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24051                 }
24052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24053         }
24054         return NDR_ERR_SUCCESS;
24055 }
24056
24057 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24058 {
24059         uint32_t cntr_info_2;
24060         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24061         ndr->depth++;
24062         if (flags & NDR_SET_VALUES) {
24063                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24064         }
24065         if (flags & NDR_IN) {
24066                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24067                 ndr->depth++;
24068                 ndr_print_ptr(ndr, "servername", r->in.servername);
24069                 ndr->depth++;
24070                 if (r->in.servername) {
24071                         ndr_print_string(ndr, "servername", r->in.servername);
24072                 }
24073                 ndr->depth--;
24074                 ndr_print_uint32(ndr, "level", r->in.level);
24075                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24076                 ndr->depth++;
24077                 if (r->in.buffer) {
24078                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24079                 }
24080                 ndr->depth--;
24081                 ndr_print_uint32(ndr, "offered", r->in.offered);
24082                 ndr->depth--;
24083         }
24084         if (flags & NDR_OUT) {
24085                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24086                 ndr->depth++;
24087                 ndr_print_ptr(ndr, "count", r->out.count);
24088                 ndr->depth++;
24089                 ndr_print_uint32(ndr, "count", *r->out.count);
24090                 ndr->depth--;
24091                 ndr_print_ptr(ndr, "info", r->out.info);
24092                 ndr->depth++;
24093                 ndr_print_ptr(ndr, "info", *r->out.info);
24094                 ndr->depth++;
24095                 if (*r->out.info) {
24096                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24097                         ndr->depth++;
24098                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24099                                 char *idx_2=NULL;
24100                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24101                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24102                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24103                                         free(idx_2);
24104                                 }
24105                         }
24106                         ndr->depth--;
24107                 }
24108                 ndr->depth--;
24109                 ndr->depth--;
24110                 ndr_print_ptr(ndr, "needed", r->out.needed);
24111                 ndr->depth++;
24112                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24113                 ndr->depth--;
24114                 ndr_print_WERROR(ndr, "result", r->out.result);
24115                 ndr->depth--;
24116         }
24117         ndr->depth--;
24118 }
24119
24120 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24121 {
24122         if (flags & NDR_IN) {
24123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24124                 if (r->in.servername) {
24125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24129                 }
24130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24132                 if (r->in.buffer) {
24133                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24134                 }
24135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24136         }
24137         if (flags & NDR_OUT) {
24138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24139                 if (r->out.info) {
24140                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24141                 }
24142                 if (r->out.needed == NULL) {
24143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24144                 }
24145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24146                 if (r->out.count == NULL) {
24147                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24148                 }
24149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24151         }
24152         return NDR_ERR_SUCCESS;
24153 }
24154
24155 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24156 {
24157         uint32_t _ptr_servername;
24158         uint32_t _ptr_buffer;
24159         uint32_t _ptr_info;
24160         TALLOC_CTX *_mem_save_servername_0;
24161         TALLOC_CTX *_mem_save_buffer_0;
24162         TALLOC_CTX *_mem_save_info_0;
24163         TALLOC_CTX *_mem_save_needed_0;
24164         TALLOC_CTX *_mem_save_count_0;
24165         if (flags & NDR_IN) {
24166                 ZERO_STRUCT(r->out);
24167
24168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24169                 if (_ptr_servername) {
24170                         NDR_PULL_ALLOC(ndr, r->in.servername);
24171                 } else {
24172                         r->in.servername = NULL;
24173                 }
24174                 if (r->in.servername) {
24175                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24176                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24178                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24179                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24180                                 return 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));
24181                         }
24182                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24183                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24185                 }
24186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24188                 if (_ptr_buffer) {
24189                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24190                 } else {
24191                         r->in.buffer = NULL;
24192                 }
24193                 if (r->in.buffer) {
24194                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24195                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24196                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24198                 }
24199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24200                 NDR_PULL_ALLOC(ndr, r->out.needed);
24201                 ZERO_STRUCTP(r->out.needed);
24202                 NDR_PULL_ALLOC(ndr, r->out.count);
24203                 ZERO_STRUCTP(r->out.count);
24204         }
24205         if (flags & NDR_OUT) {
24206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24207                 if (_ptr_info) {
24208                         NDR_PULL_ALLOC(ndr, r->out.info);
24209                 } else {
24210                         r->out.info = NULL;
24211                 }
24212                 if (r->out.info) {
24213                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24214                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24215                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24217                 }
24218                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24219                         NDR_PULL_ALLOC(ndr, r->out.needed);
24220                 }
24221                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24222                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24224                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24225                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24226                         NDR_PULL_ALLOC(ndr, r->out.count);
24227                 }
24228                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24229                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24231                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24232                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24233         }
24234         return NDR_ERR_SUCCESS;
24235 }
24236
24237 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
24238 {
24239         uint32_t cntr_info_0;
24240         if (flags & NDR_IN) {
24241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24243         }
24244         if (flags & NDR_OUT) {
24245                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24246                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24247                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24248                 }
24249                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24250                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24251                 }
24252         }
24253         return NDR_ERR_SUCCESS;
24254 }
24255
24256 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24257 {
24258         uint32_t cntr_info_0;
24259         TALLOC_CTX *_mem_save_info_0;
24260         if (flags & NDR_IN) {
24261                 ZERO_STRUCT(r->out);
24262
24263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24265         }
24266         if (flags & NDR_OUT) {
24267                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24268                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24269                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24270                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24271                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24272                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24273                 }
24274                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24275                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24276                 }
24277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24278         }
24279         return NDR_ERR_SUCCESS;
24280 }
24281
24282 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24283 {
24284         uint32_t cntr_info_2;
24285         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24286         ndr->depth++;
24287         if (flags & NDR_SET_VALUES) {
24288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24289         }
24290         if (flags & NDR_IN) {
24291                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24292                 ndr->depth++;
24293                 ndr_print_ptr(ndr, "servername", r->in.servername);
24294                 ndr->depth++;
24295                 if (r->in.servername) {
24296                         ndr_print_string(ndr, "servername", r->in.servername);
24297                 }
24298                 ndr->depth--;
24299                 ndr_print_uint32(ndr, "level", r->in.level);
24300                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24301                 ndr->depth++;
24302                 if (r->in.buffer) {
24303                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24304                 }
24305                 ndr->depth--;
24306                 ndr_print_uint32(ndr, "offered", r->in.offered);
24307                 ndr->depth--;
24308         }
24309         if (flags & NDR_OUT) {
24310                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24311                 ndr->depth++;
24312                 ndr_print_ptr(ndr, "count", r->out.count);
24313                 ndr->depth++;
24314                 ndr_print_uint32(ndr, "count", *r->out.count);
24315                 ndr->depth--;
24316                 ndr_print_ptr(ndr, "info", r->out.info);
24317                 ndr->depth++;
24318                 ndr_print_ptr(ndr, "info", *r->out.info);
24319                 ndr->depth++;
24320                 if (*r->out.info) {
24321                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24322                         ndr->depth++;
24323                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24324                                 char *idx_2=NULL;
24325                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24326                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24327                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24328                                         free(idx_2);
24329                                 }
24330                         }
24331                         ndr->depth--;
24332                 }
24333                 ndr->depth--;
24334                 ndr->depth--;
24335                 ndr_print_ptr(ndr, "needed", r->out.needed);
24336                 ndr->depth++;
24337                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24338                 ndr->depth--;
24339                 ndr_print_WERROR(ndr, "result", r->out.result);
24340                 ndr->depth--;
24341         }
24342         ndr->depth--;
24343 }
24344
24345 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24346 {
24347         if (flags & NDR_IN) {
24348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24349                 if (r->in.server_name) {
24350                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24351                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24352                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24353                         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));
24354                 }
24355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24356                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24357                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24358                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24359                 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));
24360         }
24361         if (flags & NDR_OUT) {
24362                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24363         }
24364         return NDR_ERR_SUCCESS;
24365 }
24366
24367 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
24368 {
24369         uint32_t _ptr_server_name;
24370         TALLOC_CTX *_mem_save_server_name_0;
24371         if (flags & NDR_IN) {
24372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
24373                 if (_ptr_server_name) {
24374                         NDR_PULL_ALLOC(ndr, r->in.server_name);
24375                 } else {
24376                         r->in.server_name = NULL;
24377                 }
24378                 if (r->in.server_name) {
24379                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24380                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
24381                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24382                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24383                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24384                                 return 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));
24385                         }
24386                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24387                         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));
24388                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
24389                 }
24390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
24391                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
24392                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
24393                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
24394                         return 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));
24395                 }
24396                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
24397                 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));
24398         }
24399         if (flags & NDR_OUT) {
24400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24401         }
24402         return NDR_ERR_SUCCESS;
24403 }
24404
24405 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
24406 {
24407         ndr_print_struct(ndr, name, "spoolss_AddPort");
24408         ndr->depth++;
24409         if (flags & NDR_SET_VALUES) {
24410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24411         }
24412         if (flags & NDR_IN) {
24413                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
24414                 ndr->depth++;
24415                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
24416                 ndr->depth++;
24417                 if (r->in.server_name) {
24418                         ndr_print_string(ndr, "server_name", r->in.server_name);
24419                 }
24420                 ndr->depth--;
24421                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
24422                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
24423                 ndr->depth--;
24424         }
24425         if (flags & NDR_OUT) {
24426                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
24427                 ndr->depth++;
24428                 ndr_print_WERROR(ndr, "result", r->out.result);
24429                 ndr->depth--;
24430         }
24431         ndr->depth--;
24432 }
24433
24434 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
24435 {
24436         if (flags & NDR_IN) {
24437         }
24438         if (flags & NDR_OUT) {
24439                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24440         }
24441         return NDR_ERR_SUCCESS;
24442 }
24443
24444 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
24445 {
24446         if (flags & NDR_IN) {
24447         }
24448         if (flags & NDR_OUT) {
24449                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24450         }
24451         return NDR_ERR_SUCCESS;
24452 }
24453
24454 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
24455 {
24456         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
24457         ndr->depth++;
24458         if (flags & NDR_SET_VALUES) {
24459                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24460         }
24461         if (flags & NDR_IN) {
24462                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24463                 ndr->depth++;
24464                 ndr->depth--;
24465         }
24466         if (flags & NDR_OUT) {
24467                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24468                 ndr->depth++;
24469                 ndr_print_WERROR(ndr, "result", r->out.result);
24470                 ndr->depth--;
24471         }
24472         ndr->depth--;
24473 }
24474
24475 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24476 {
24477         if (flags & NDR_IN) {
24478         }
24479         if (flags & NDR_OUT) {
24480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24481         }
24482         return NDR_ERR_SUCCESS;
24483 }
24484
24485 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24486 {
24487         if (flags & NDR_IN) {
24488         }
24489         if (flags & NDR_OUT) {
24490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24491         }
24492         return NDR_ERR_SUCCESS;
24493 }
24494
24495 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24496 {
24497         ndr_print_struct(ndr, name, "spoolss_DeletePort");
24498         ndr->depth++;
24499         if (flags & NDR_SET_VALUES) {
24500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24501         }
24502         if (flags & NDR_IN) {
24503                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24504                 ndr->depth++;
24505                 ndr->depth--;
24506         }
24507         if (flags & NDR_OUT) {
24508                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24509                 ndr->depth++;
24510                 ndr_print_WERROR(ndr, "result", r->out.result);
24511                 ndr->depth--;
24512         }
24513         ndr->depth--;
24514 }
24515
24516 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24517 {
24518         if (flags & NDR_IN) {
24519                 if (r->in.handle == NULL) {
24520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24521                 }
24522                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24523                 if (r->in.devmode_ctr == NULL) {
24524                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24525                 }
24526                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24527         }
24528         if (flags & NDR_OUT) {
24529                 if (r->out.gdi_handle == NULL) {
24530                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24531                 }
24532                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24534         }
24535         return NDR_ERR_SUCCESS;
24536 }
24537
24538 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24539 {
24540         TALLOC_CTX *_mem_save_handle_0;
24541         TALLOC_CTX *_mem_save_gdi_handle_0;
24542         TALLOC_CTX *_mem_save_devmode_ctr_0;
24543         if (flags & NDR_IN) {
24544                 ZERO_STRUCT(r->out);
24545
24546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24547                         NDR_PULL_ALLOC(ndr, r->in.handle);
24548                 }
24549                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24550                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24551                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24554                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24555                 }
24556                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24558                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24560                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24561                 ZERO_STRUCTP(r->out.gdi_handle);
24562         }
24563         if (flags & NDR_OUT) {
24564                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24565                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24566                 }
24567                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24568                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24569                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24570                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24571                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24572         }
24573         return NDR_ERR_SUCCESS;
24574 }
24575
24576 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
24577 {
24578         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
24579         ndr->depth++;
24580         if (flags & NDR_SET_VALUES) {
24581                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24582         }
24583         if (flags & NDR_IN) {
24584                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
24585                 ndr->depth++;
24586                 ndr_print_ptr(ndr, "handle", r->in.handle);
24587                 ndr->depth++;
24588                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24589                 ndr->depth--;
24590                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24591                 ndr->depth++;
24592                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24593                 ndr->depth--;
24594                 ndr->depth--;
24595         }
24596         if (flags & NDR_OUT) {
24597                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
24598                 ndr->depth++;
24599                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24600                 ndr->depth++;
24601                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24602                 ndr->depth--;
24603                 ndr_print_WERROR(ndr, "result", r->out.result);
24604                 ndr->depth--;
24605         }
24606         ndr->depth--;
24607 }
24608
24609 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24610 {
24611         if (flags & NDR_IN) {
24612         }
24613         if (flags & NDR_OUT) {
24614                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24615         }
24616         return NDR_ERR_SUCCESS;
24617 }
24618
24619 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
24620 {
24621         if (flags & NDR_IN) {
24622         }
24623         if (flags & NDR_OUT) {
24624                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24625         }
24626         return NDR_ERR_SUCCESS;
24627 }
24628
24629 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24630 {
24631         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
24632         ndr->depth++;
24633         if (flags & NDR_SET_VALUES) {
24634                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24635         }
24636         if (flags & NDR_IN) {
24637                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
24638                 ndr->depth++;
24639                 ndr->depth--;
24640         }
24641         if (flags & NDR_OUT) {
24642                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
24643                 ndr->depth++;
24644                 ndr_print_WERROR(ndr, "result", r->out.result);
24645                 ndr->depth--;
24646         }
24647         ndr->depth--;
24648 }
24649
24650 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
24651 {
24652         if (flags & NDR_IN) {
24653                 if (r->in.gdi_handle == NULL) {
24654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24655                 }
24656                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24657         }
24658         if (flags & NDR_OUT) {
24659                 if (r->out.gdi_handle == NULL) {
24660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24661                 }
24662                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24663                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24664         }
24665         return NDR_ERR_SUCCESS;
24666 }
24667
24668 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
24669 {
24670         TALLOC_CTX *_mem_save_gdi_handle_0;
24671         if (flags & NDR_IN) {
24672                 ZERO_STRUCT(r->out);
24673
24674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24675                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
24676                 }
24677                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24678                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24679                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24681                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24682                 *r->out.gdi_handle = *r->in.gdi_handle;
24683         }
24684         if (flags & NDR_OUT) {
24685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24686                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24687                 }
24688                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24689                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24692                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24693         }
24694         return NDR_ERR_SUCCESS;
24695 }
24696
24697 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
24698 {
24699         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
24700         ndr->depth++;
24701         if (flags & NDR_SET_VALUES) {
24702                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24703         }
24704         if (flags & NDR_IN) {
24705                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
24706                 ndr->depth++;
24707                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
24708                 ndr->depth++;
24709                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
24710                 ndr->depth--;
24711                 ndr->depth--;
24712         }
24713         if (flags & NDR_OUT) {
24714                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
24715                 ndr->depth++;
24716                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24717                 ndr->depth++;
24718                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24719                 ndr->depth--;
24720                 ndr_print_WERROR(ndr, "result", r->out.result);
24721                 ndr->depth--;
24722         }
24723         ndr->depth--;
24724 }
24725
24726 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
24727 {
24728         if (flags & NDR_IN) {
24729         }
24730         if (flags & NDR_OUT) {
24731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24732         }
24733         return NDR_ERR_SUCCESS;
24734 }
24735
24736 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
24737 {
24738         if (flags & NDR_IN) {
24739         }
24740         if (flags & NDR_OUT) {
24741                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24742         }
24743         return NDR_ERR_SUCCESS;
24744 }
24745
24746 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
24747 {
24748         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
24749         ndr->depth++;
24750         if (flags & NDR_SET_VALUES) {
24751                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24752         }
24753         if (flags & NDR_IN) {
24754                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
24755                 ndr->depth++;
24756                 ndr->depth--;
24757         }
24758         if (flags & NDR_OUT) {
24759                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
24760                 ndr->depth++;
24761                 ndr_print_WERROR(ndr, "result", r->out.result);
24762                 ndr->depth--;
24763         }
24764         ndr->depth--;
24765 }
24766
24767 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
24768 {
24769         if (flags & NDR_IN) {
24770         }
24771         if (flags & NDR_OUT) {
24772                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24773         }
24774         return NDR_ERR_SUCCESS;
24775 }
24776
24777 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
24778 {
24779         if (flags & NDR_IN) {
24780         }
24781         if (flags & NDR_OUT) {
24782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24783         }
24784         return NDR_ERR_SUCCESS;
24785 }
24786
24787 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
24788 {
24789         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
24790         ndr->depth++;
24791         if (flags & NDR_SET_VALUES) {
24792                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24793         }
24794         if (flags & NDR_IN) {
24795                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
24796                 ndr->depth++;
24797                 ndr->depth--;
24798         }
24799         if (flags & NDR_OUT) {
24800                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
24801                 ndr->depth++;
24802                 ndr_print_WERROR(ndr, "result", r->out.result);
24803                 ndr->depth--;
24804         }
24805         ndr->depth--;
24806 }
24807
24808 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
24809 {
24810         if (flags & NDR_IN) {
24811         }
24812         if (flags & NDR_OUT) {
24813                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24814         }
24815         return NDR_ERR_SUCCESS;
24816 }
24817
24818 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
24819 {
24820         if (flags & NDR_IN) {
24821         }
24822         if (flags & NDR_OUT) {
24823                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24824         }
24825         return NDR_ERR_SUCCESS;
24826 }
24827
24828 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
24829 {
24830         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
24831         ndr->depth++;
24832         if (flags & NDR_SET_VALUES) {
24833                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24834         }
24835         if (flags & NDR_IN) {
24836                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
24837                 ndr->depth++;
24838                 ndr->depth--;
24839         }
24840         if (flags & NDR_OUT) {
24841                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
24842                 ndr->depth++;
24843                 ndr_print_WERROR(ndr, "result", r->out.result);
24844                 ndr->depth--;
24845         }
24846         ndr->depth--;
24847 }
24848
24849 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
24850 {
24851         if (flags & NDR_IN) {
24852         }
24853         if (flags & NDR_OUT) {
24854                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24855         }
24856         return NDR_ERR_SUCCESS;
24857 }
24858
24859 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
24860 {
24861         if (flags & NDR_IN) {
24862         }
24863         if (flags & NDR_OUT) {
24864                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24865         }
24866         return NDR_ERR_SUCCESS;
24867 }
24868
24869 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
24870 {
24871         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
24872         ndr->depth++;
24873         if (flags & NDR_SET_VALUES) {
24874                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24875         }
24876         if (flags & NDR_IN) {
24877                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
24878                 ndr->depth++;
24879                 ndr->depth--;
24880         }
24881         if (flags & NDR_OUT) {
24882                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
24883                 ndr->depth++;
24884                 ndr_print_WERROR(ndr, "result", r->out.result);
24885                 ndr->depth--;
24886         }
24887         ndr->depth--;
24888 }
24889
24890 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
24891 {
24892         if (flags & NDR_IN) {
24893         }
24894         if (flags & NDR_OUT) {
24895                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24896         }
24897         return NDR_ERR_SUCCESS;
24898 }
24899
24900 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
24901 {
24902         if (flags & NDR_IN) {
24903         }
24904         if (flags & NDR_OUT) {
24905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24906         }
24907         return NDR_ERR_SUCCESS;
24908 }
24909
24910 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
24911 {
24912         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
24913         ndr->depth++;
24914         if (flags & NDR_SET_VALUES) {
24915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24916         }
24917         if (flags & NDR_IN) {
24918                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
24919                 ndr->depth++;
24920                 ndr->depth--;
24921         }
24922         if (flags & NDR_OUT) {
24923                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
24924                 ndr->depth++;
24925                 ndr_print_WERROR(ndr, "result", r->out.result);
24926                 ndr->depth--;
24927         }
24928         ndr->depth--;
24929 }
24930
24931 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
24932 {
24933         if (flags & NDR_IN) {
24934         }
24935         if (flags & NDR_OUT) {
24936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24937         }
24938         return NDR_ERR_SUCCESS;
24939 }
24940
24941 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
24942 {
24943         if (flags & NDR_IN) {
24944         }
24945         if (flags & NDR_OUT) {
24946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24947         }
24948         return NDR_ERR_SUCCESS;
24949 }
24950
24951 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
24952 {
24953         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
24954         ndr->depth++;
24955         if (flags & NDR_SET_VALUES) {
24956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24957         }
24958         if (flags & NDR_IN) {
24959                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
24960                 ndr->depth++;
24961                 ndr->depth--;
24962         }
24963         if (flags & NDR_OUT) {
24964                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
24965                 ndr->depth++;
24966                 ndr_print_WERROR(ndr, "result", r->out.result);
24967                 ndr->depth--;
24968         }
24969         ndr->depth--;
24970 }
24971
24972 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
24973 {
24974         if (flags & NDR_IN) {
24975         }
24976         if (flags & NDR_OUT) {
24977                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24978         }
24979         return NDR_ERR_SUCCESS;
24980 }
24981
24982 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
24983 {
24984         if (flags & NDR_IN) {
24985         }
24986         if (flags & NDR_OUT) {
24987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24988         }
24989         return NDR_ERR_SUCCESS;
24990 }
24991
24992 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
24993 {
24994         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
24995         ndr->depth++;
24996         if (flags & NDR_SET_VALUES) {
24997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24998         }
24999         if (flags & NDR_IN) {
25000                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25001                 ndr->depth++;
25002                 ndr->depth--;
25003         }
25004         if (flags & NDR_OUT) {
25005                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25006                 ndr->depth++;
25007                 ndr_print_WERROR(ndr, "result", r->out.result);
25008                 ndr->depth--;
25009         }
25010         ndr->depth--;
25011 }
25012
25013 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25014 {
25015         if (flags & NDR_IN) {
25016         }
25017         if (flags & NDR_OUT) {
25018                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25019         }
25020         return NDR_ERR_SUCCESS;
25021 }
25022
25023 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25024 {
25025         if (flags & NDR_IN) {
25026         }
25027         if (flags & NDR_OUT) {
25028                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25029         }
25030         return NDR_ERR_SUCCESS;
25031 }
25032
25033 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25034 {
25035         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25036         ndr->depth++;
25037         if (flags & NDR_SET_VALUES) {
25038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25039         }
25040         if (flags & NDR_IN) {
25041                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25042                 ndr->depth++;
25043                 ndr->depth--;
25044         }
25045         if (flags & NDR_OUT) {
25046                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25047                 ndr->depth++;
25048                 ndr_print_WERROR(ndr, "result", r->out.result);
25049                 ndr->depth--;
25050         }
25051         ndr->depth--;
25052 }
25053
25054 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25055 {
25056         if (flags & NDR_IN) {
25057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25058                 if (r->in.servername) {
25059                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25060                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25061                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25063                 }
25064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25065                 if (r->in.print_processor_name) {
25066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25068                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25069                         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));
25070                 }
25071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25073                 if (r->in.buffer) {
25074                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25075                 }
25076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25077         }
25078         if (flags & NDR_OUT) {
25079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25080                 if (r->out.info) {
25081                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25082                 }
25083                 if (r->out.needed == NULL) {
25084                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25085                 }
25086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25087                 if (r->out.count == NULL) {
25088                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25089                 }
25090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25091                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25092         }
25093         return NDR_ERR_SUCCESS;
25094 }
25095
25096 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25097 {
25098         uint32_t _ptr_servername;
25099         uint32_t _ptr_print_processor_name;
25100         uint32_t _ptr_buffer;
25101         uint32_t _ptr_info;
25102         TALLOC_CTX *_mem_save_servername_0;
25103         TALLOC_CTX *_mem_save_print_processor_name_0;
25104         TALLOC_CTX *_mem_save_buffer_0;
25105         TALLOC_CTX *_mem_save_info_0;
25106         TALLOC_CTX *_mem_save_needed_0;
25107         TALLOC_CTX *_mem_save_count_0;
25108         if (flags & NDR_IN) {
25109                 ZERO_STRUCT(r->out);
25110
25111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25112                 if (_ptr_servername) {
25113                         NDR_PULL_ALLOC(ndr, r->in.servername);
25114                 } else {
25115                         r->in.servername = NULL;
25116                 }
25117                 if (r->in.servername) {
25118                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25119                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25121                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25122                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25123                                 return 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));
25124                         }
25125                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25126                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25128                 }
25129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25130                 if (_ptr_print_processor_name) {
25131                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25132                 } else {
25133                         r->in.print_processor_name = NULL;
25134                 }
25135                 if (r->in.print_processor_name) {
25136                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25137                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25138                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25139                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25140                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25141                                 return 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));
25142                         }
25143                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25144                         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));
25145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25146                 }
25147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25149                 if (_ptr_buffer) {
25150                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25151                 } else {
25152                         r->in.buffer = NULL;
25153                 }
25154                 if (r->in.buffer) {
25155                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25156                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25157                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25159                 }
25160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25161                 NDR_PULL_ALLOC(ndr, r->out.needed);
25162                 ZERO_STRUCTP(r->out.needed);
25163                 NDR_PULL_ALLOC(ndr, r->out.count);
25164                 ZERO_STRUCTP(r->out.count);
25165         }
25166         if (flags & NDR_OUT) {
25167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25168                 if (_ptr_info) {
25169                         NDR_PULL_ALLOC(ndr, r->out.info);
25170                 } else {
25171                         r->out.info = NULL;
25172                 }
25173                 if (r->out.info) {
25174                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25175                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25176                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25177                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25178                 }
25179                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25180                         NDR_PULL_ALLOC(ndr, r->out.needed);
25181                 }
25182                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25183                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25187                         NDR_PULL_ALLOC(ndr, r->out.count);
25188                 }
25189                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25190                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25192                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25194         }
25195         return NDR_ERR_SUCCESS;
25196 }
25197
25198 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25199 {
25200         uint32_t cntr_info_0;
25201         if (flags & NDR_IN) {
25202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25204         }
25205         if (flags & NDR_OUT) {
25206                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25207                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25208                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25209                 }
25210                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25211                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25212                 }
25213         }
25214         return NDR_ERR_SUCCESS;
25215 }
25216
25217 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25218 {
25219         uint32_t cntr_info_0;
25220         TALLOC_CTX *_mem_save_info_0;
25221         if (flags & NDR_IN) {
25222                 ZERO_STRUCT(r->out);
25223
25224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25226         }
25227         if (flags & NDR_OUT) {
25228                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25229                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25230                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25231                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25232                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25233                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25234                 }
25235                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25236                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25237                 }
25238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25239         }
25240         return NDR_ERR_SUCCESS;
25241 }
25242
25243 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
25244 {
25245         uint32_t cntr_info_2;
25246         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
25247         ndr->depth++;
25248         if (flags & NDR_SET_VALUES) {
25249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25250         }
25251         if (flags & NDR_IN) {
25252                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
25253                 ndr->depth++;
25254                 ndr_print_ptr(ndr, "servername", r->in.servername);
25255                 ndr->depth++;
25256                 if (r->in.servername) {
25257                         ndr_print_string(ndr, "servername", r->in.servername);
25258                 }
25259                 ndr->depth--;
25260                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25261                 ndr->depth++;
25262                 if (r->in.print_processor_name) {
25263                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25264                 }
25265                 ndr->depth--;
25266                 ndr_print_uint32(ndr, "level", r->in.level);
25267                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25268                 ndr->depth++;
25269                 if (r->in.buffer) {
25270                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25271                 }
25272                 ndr->depth--;
25273                 ndr_print_uint32(ndr, "offered", r->in.offered);
25274                 ndr->depth--;
25275         }
25276         if (flags & NDR_OUT) {
25277                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25278                 ndr->depth++;
25279                 ndr_print_ptr(ndr, "count", r->out.count);
25280                 ndr->depth++;
25281                 ndr_print_uint32(ndr, "count", *r->out.count);
25282                 ndr->depth--;
25283                 ndr_print_ptr(ndr, "info", r->out.info);
25284                 ndr->depth++;
25285                 ndr_print_ptr(ndr, "info", *r->out.info);
25286                 ndr->depth++;
25287                 if (*r->out.info) {
25288                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25289                         ndr->depth++;
25290                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25291                                 char *idx_2=NULL;
25292                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25293                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25294                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25295                                         free(idx_2);
25296                                 }
25297                         }
25298                         ndr->depth--;
25299                 }
25300                 ndr->depth--;
25301                 ndr->depth--;
25302                 ndr_print_ptr(ndr, "needed", r->out.needed);
25303                 ndr->depth++;
25304                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25305                 ndr->depth--;
25306                 ndr_print_WERROR(ndr, "result", r->out.result);
25307                 ndr->depth--;
25308         }
25309         ndr->depth--;
25310 }
25311
25312 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25313 {
25314         if (flags & NDR_IN) {
25315                 if (r->in.handle == NULL) {
25316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25317                 }
25318                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25320                 if (r->in.data_type) {
25321                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25322                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25323                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25324                         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));
25325                 }
25326                 if (r->in.devmode_ctr == NULL) {
25327                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25328                 }
25329                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25330         }
25331         if (flags & NDR_OUT) {
25332                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25333         }
25334         return NDR_ERR_SUCCESS;
25335 }
25336
25337 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25338 {
25339         uint32_t _ptr_data_type;
25340         TALLOC_CTX *_mem_save_handle_0;
25341         TALLOC_CTX *_mem_save_data_type_0;
25342         TALLOC_CTX *_mem_save_devmode_ctr_0;
25343         if (flags & NDR_IN) {
25344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25345                         NDR_PULL_ALLOC(ndr, r->in.handle);
25346                 }
25347                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25348                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25349                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25351                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25352                 if (_ptr_data_type) {
25353                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25354                 } else {
25355                         r->in.data_type = NULL;
25356                 }
25357                 if (r->in.data_type) {
25358                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25359                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25362                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25363                                 return 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));
25364                         }
25365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
25366                         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));
25367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
25368                 }
25369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25370                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25371                 }
25372                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25373                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25374                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25376         }
25377         if (flags & NDR_OUT) {
25378                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25379         }
25380         return NDR_ERR_SUCCESS;
25381 }
25382
25383 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
25384 {
25385         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
25386         ndr->depth++;
25387         if (flags & NDR_SET_VALUES) {
25388                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25389         }
25390         if (flags & NDR_IN) {
25391                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
25392                 ndr->depth++;
25393                 ndr_print_ptr(ndr, "handle", r->in.handle);
25394                 ndr->depth++;
25395                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25396                 ndr->depth--;
25397                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
25398                 ndr->depth++;
25399                 if (r->in.data_type) {
25400                         ndr_print_string(ndr, "data_type", r->in.data_type);
25401                 }
25402                 ndr->depth--;
25403                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25404                 ndr->depth++;
25405                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25406                 ndr->depth--;
25407                 ndr->depth--;
25408         }
25409         if (flags & NDR_OUT) {
25410                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
25411                 ndr->depth++;
25412                 ndr_print_WERROR(ndr, "result", r->out.result);
25413                 ndr->depth--;
25414         }
25415         ndr->depth--;
25416 }
25417
25418 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
25419 {
25420         if (flags & NDR_IN) {
25421                 if (r->in.handle == NULL) {
25422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25423                 }
25424                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
25426                 if (r->in.architecture) {
25427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25430                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25431                 }
25432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25434                 if (r->in.buffer) {
25435                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25436                 }
25437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
25439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
25440         }
25441         if (flags & NDR_OUT) {
25442                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25443                 if (r->out.info) {
25444                         {
25445                                 struct ndr_push *_ndr_info;
25446                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25447                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
25448                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25449                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25450                         }
25451                 }
25452                 if (r->out.needed == NULL) {
25453                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25454                 }
25455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25456                 if (r->out.server_major_version == NULL) {
25457                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25458                 }
25459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
25460                 if (r->out.server_minor_version == NULL) {
25461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25462                 }
25463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
25464                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25465         }
25466         return NDR_ERR_SUCCESS;
25467 }
25468
25469 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
25470 {
25471         uint32_t _ptr_architecture;
25472         uint32_t _ptr_buffer;
25473         uint32_t _ptr_info;
25474         TALLOC_CTX *_mem_save_handle_0;
25475         TALLOC_CTX *_mem_save_architecture_0;
25476         TALLOC_CTX *_mem_save_buffer_0;
25477         TALLOC_CTX *_mem_save_info_0;
25478         TALLOC_CTX *_mem_save_needed_0;
25479         TALLOC_CTX *_mem_save_server_major_version_0;
25480         TALLOC_CTX *_mem_save_server_minor_version_0;
25481         if (flags & NDR_IN) {
25482                 ZERO_STRUCT(r->out);
25483
25484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25485                         NDR_PULL_ALLOC(ndr, r->in.handle);
25486                 }
25487                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25488                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25489                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
25492                 if (_ptr_architecture) {
25493                         NDR_PULL_ALLOC(ndr, r->in.architecture);
25494                 } else {
25495                         r->in.architecture = NULL;
25496                 }
25497                 if (r->in.architecture) {
25498                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
25499                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
25500                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
25501                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
25502                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
25503                                 return 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));
25504                         }
25505                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
25506                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
25507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
25508                 }
25509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25511                 if (_ptr_buffer) {
25512                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25513                 } else {
25514                         r->in.buffer = NULL;
25515                 }
25516                 if (r->in.buffer) {
25517                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25518                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25519                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25521                 }
25522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
25524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
25525                 NDR_PULL_ALLOC(ndr, r->out.needed);
25526                 ZERO_STRUCTP(r->out.needed);
25527                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25528                 ZERO_STRUCTP(r->out.server_major_version);
25529                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25530                 ZERO_STRUCTP(r->out.server_minor_version);
25531         }
25532         if (flags & NDR_OUT) {
25533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25534                 if (_ptr_info) {
25535                         NDR_PULL_ALLOC(ndr, r->out.info);
25536                 } else {
25537                         r->out.info = NULL;
25538                 }
25539                 if (r->out.info) {
25540                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25541                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25542                         {
25543                                 struct ndr_pull *_ndr_info;
25544                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25545                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
25546                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25547                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25548                         }
25549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25550                 }
25551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25552                         NDR_PULL_ALLOC(ndr, r->out.needed);
25553                 }
25554                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25555                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25559                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25560                 }
25561                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25562                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25566                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25567                 }
25568                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25569                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
25570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
25571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
25572                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25573         }
25574         return NDR_ERR_SUCCESS;
25575 }
25576
25577 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
25578 {
25579         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
25580         ndr->depth++;
25581         if (flags & NDR_SET_VALUES) {
25582                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25583         }
25584         if (flags & NDR_IN) {
25585                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
25586                 ndr->depth++;
25587                 ndr_print_ptr(ndr, "handle", r->in.handle);
25588                 ndr->depth++;
25589                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25590                 ndr->depth--;
25591                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
25592                 ndr->depth++;
25593                 if (r->in.architecture) {
25594                         ndr_print_string(ndr, "architecture", r->in.architecture);
25595                 }
25596                 ndr->depth--;
25597                 ndr_print_uint32(ndr, "level", r->in.level);
25598                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25599                 ndr->depth++;
25600                 if (r->in.buffer) {
25601                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25602                 }
25603                 ndr->depth--;
25604                 ndr_print_uint32(ndr, "offered", r->in.offered);
25605                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
25606                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
25607                 ndr->depth--;
25608         }
25609         if (flags & NDR_OUT) {
25610                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
25611                 ndr->depth++;
25612                 ndr_print_ptr(ndr, "info", r->out.info);
25613                 ndr->depth++;
25614                 if (r->out.info) {
25615                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
25616                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
25617                 }
25618                 ndr->depth--;
25619                 ndr_print_ptr(ndr, "needed", r->out.needed);
25620                 ndr->depth++;
25621                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25622                 ndr->depth--;
25623                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
25624                 ndr->depth++;
25625                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
25626                 ndr->depth--;
25627                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
25628                 ndr->depth++;
25629                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
25630                 ndr->depth--;
25631                 ndr_print_WERROR(ndr, "result", r->out.result);
25632                 ndr->depth--;
25633         }
25634         ndr->depth--;
25635 }
25636
25637 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25638 {
25639         if (flags & NDR_IN) {
25640         }
25641         if (flags & NDR_OUT) {
25642                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25643         }
25644         return NDR_ERR_SUCCESS;
25645 }
25646
25647 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
25648 {
25649         if (flags & NDR_IN) {
25650         }
25651         if (flags & NDR_OUT) {
25652                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25653         }
25654         return NDR_ERR_SUCCESS;
25655 }
25656
25657 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25658 {
25659         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
25660         ndr->depth++;
25661         if (flags & NDR_SET_VALUES) {
25662                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25663         }
25664         if (flags & NDR_IN) {
25665                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
25666                 ndr->depth++;
25667                 ndr->depth--;
25668         }
25669         if (flags & NDR_OUT) {
25670                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
25671                 ndr->depth++;
25672                 ndr_print_WERROR(ndr, "result", r->out.result);
25673                 ndr->depth--;
25674         }
25675         ndr->depth--;
25676 }
25677
25678 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25679 {
25680         if (flags & NDR_IN) {
25681         }
25682         if (flags & NDR_OUT) {
25683                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25684         }
25685         return NDR_ERR_SUCCESS;
25686 }
25687
25688 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
25689 {
25690         if (flags & NDR_IN) {
25691         }
25692         if (flags & NDR_OUT) {
25693                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25694         }
25695         return NDR_ERR_SUCCESS;
25696 }
25697
25698 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25699 {
25700         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
25701         ndr->depth++;
25702         if (flags & NDR_SET_VALUES) {
25703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25704         }
25705         if (flags & NDR_IN) {
25706                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
25707                 ndr->depth++;
25708                 ndr->depth--;
25709         }
25710         if (flags & NDR_OUT) {
25711                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
25712                 ndr->depth++;
25713                 ndr_print_WERROR(ndr, "result", r->out.result);
25714                 ndr->depth--;
25715         }
25716         ndr->depth--;
25717 }
25718
25719 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
25720 {
25721         if (flags & NDR_IN) {
25722                 if (r->in.handle == NULL) {
25723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25724                 }
25725                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25726         }
25727         if (flags & NDR_OUT) {
25728                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25729         }
25730         return NDR_ERR_SUCCESS;
25731 }
25732
25733 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
25734 {
25735         TALLOC_CTX *_mem_save_handle_0;
25736         if (flags & NDR_IN) {
25737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25738                         NDR_PULL_ALLOC(ndr, r->in.handle);
25739                 }
25740                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25741                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25742                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25744         }
25745         if (flags & NDR_OUT) {
25746                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25747         }
25748         return NDR_ERR_SUCCESS;
25749 }
25750
25751 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
25752 {
25753         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
25754         ndr->depth++;
25755         if (flags & NDR_SET_VALUES) {
25756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25757         }
25758         if (flags & NDR_IN) {
25759                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
25760                 ndr->depth++;
25761                 ndr_print_ptr(ndr, "handle", r->in.handle);
25762                 ndr->depth++;
25763                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25764                 ndr->depth--;
25765                 ndr->depth--;
25766         }
25767         if (flags & NDR_OUT) {
25768                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
25769                 ndr->depth++;
25770                 ndr_print_WERROR(ndr, "result", r->out.result);
25771                 ndr->depth--;
25772         }
25773         ndr->depth--;
25774 }
25775
25776 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25777 {
25778         if (flags & NDR_IN) {
25779         }
25780         if (flags & NDR_OUT) {
25781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25782         }
25783         return NDR_ERR_SUCCESS;
25784 }
25785
25786 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25787 {
25788         if (flags & NDR_IN) {
25789         }
25790         if (flags & NDR_OUT) {
25791                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25792         }
25793         return NDR_ERR_SUCCESS;
25794 }
25795
25796 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25797 {
25798         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25799         ndr->depth++;
25800         if (flags & NDR_SET_VALUES) {
25801                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25802         }
25803         if (flags & NDR_IN) {
25804                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25805                 ndr->depth++;
25806                 ndr->depth--;
25807         }
25808         if (flags & NDR_OUT) {
25809                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25810                 ndr->depth++;
25811                 ndr_print_WERROR(ndr, "result", r->out.result);
25812                 ndr->depth--;
25813         }
25814         ndr->depth--;
25815 }
25816
25817 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
25818 {
25819         if (flags & NDR_IN) {
25820                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25821                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25822                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25823                 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));
25824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25825                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
25826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25827                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25828                 if (r->in.buffer) {
25829                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
25830                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25831                 }
25832         }
25833         if (flags & NDR_OUT) {
25834                 if (r->out.handle == NULL) {
25835                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25836                 }
25837                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25838                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25839         }
25840         return NDR_ERR_SUCCESS;
25841 }
25842
25843 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
25844 {
25845         uint32_t _ptr_buffer;
25846         TALLOC_CTX *_mem_save_buffer_0;
25847         TALLOC_CTX *_mem_save_handle_0;
25848         if (flags & NDR_IN) {
25849                 ZERO_STRUCT(r->out);
25850
25851                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25852                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25853                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25854                         return 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));
25855                 }
25856                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25857                 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));
25858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25859                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
25860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25861                 if (r->in.bufsize > 512) {
25862                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25863                 }
25864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25865                 if (_ptr_buffer) {
25866                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25867                 } else {
25868                         r->in.buffer = NULL;
25869                 }
25870                 if (r->in.buffer) {
25871                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25872                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25874                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25875                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25877                 }
25878                 NDR_PULL_ALLOC(ndr, r->out.handle);
25879                 ZERO_STRUCTP(r->out.handle);
25880                 if (r->in.buffer) {
25881                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25882                 }
25883         }
25884         if (flags & NDR_OUT) {
25885                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25886                         NDR_PULL_ALLOC(ndr, r->out.handle);
25887                 }
25888                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25889                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25890                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25891                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25892                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25893         }
25894         return NDR_ERR_SUCCESS;
25895 }
25896
25897 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
25898 {
25899         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
25900         ndr->depth++;
25901         if (flags & NDR_SET_VALUES) {
25902                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25903         }
25904         if (flags & NDR_IN) {
25905                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
25906                 ndr->depth++;
25907                 ndr_print_string(ndr, "server_name", r->in.server_name);
25908                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25909                 ndr_print_winreg_Type(ndr, "type", r->in.type);
25910                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
25911                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25912                 ndr->depth++;
25913                 if (r->in.buffer) {
25914                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
25915                 }
25916                 ndr->depth--;
25917                 ndr->depth--;
25918         }
25919         if (flags & NDR_OUT) {
25920                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
25921                 ndr->depth++;
25922                 ndr_print_ptr(ndr, "handle", r->out.handle);
25923                 ndr->depth++;
25924                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25925                 ndr->depth--;
25926                 ndr_print_WERROR(ndr, "result", r->out.result);
25927                 ndr->depth--;
25928         }
25929         ndr->depth--;
25930 }
25931
25932 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
25933 {
25934         if (flags & NDR_IN) {
25935                 if (r->in.handle == NULL) {
25936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25937                 }
25938                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25939                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25942                 if (r->in.buffer) {
25943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
25944                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25945                 }
25946         }
25947         if (flags & NDR_OUT) {
25948                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25949         }
25950         return NDR_ERR_SUCCESS;
25951 }
25952
25953 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
25954 {
25955         uint32_t _ptr_buffer;
25956         TALLOC_CTX *_mem_save_handle_0;
25957         TALLOC_CTX *_mem_save_buffer_0;
25958         if (flags & NDR_IN) {
25959                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25960                         NDR_PULL_ALLOC(ndr, r->in.handle);
25961                 }
25962                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25963                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25964                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25966                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25968                 if (r->in.bufsize > 512) {
25969                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25970                 }
25971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25972                 if (_ptr_buffer) {
25973                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25974                 } else {
25975                         r->in.buffer = NULL;
25976                 }
25977                 if (r->in.buffer) {
25978                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25979                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25981                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25982                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25984                 }
25985                 if (r->in.buffer) {
25986                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25987                 }
25988         }
25989         if (flags & NDR_OUT) {
25990                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25991         }
25992         return NDR_ERR_SUCCESS;
25993 }
25994
25995 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
25996 {
25997         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
25998         ndr->depth++;
25999         if (flags & NDR_SET_VALUES) {
26000                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26001         }
26002         if (flags & NDR_IN) {
26003                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26004                 ndr->depth++;
26005                 ndr_print_ptr(ndr, "handle", r->in.handle);
26006                 ndr->depth++;
26007                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26008                 ndr->depth--;
26009                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26010                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26011                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26012                 ndr->depth++;
26013                 if (r->in.buffer) {
26014                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26015                 }
26016                 ndr->depth--;
26017                 ndr->depth--;
26018         }
26019         if (flags & NDR_OUT) {
26020                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26021                 ndr->depth++;
26022                 ndr_print_WERROR(ndr, "result", r->out.result);
26023                 ndr->depth--;
26024         }
26025         ndr->depth--;
26026 }
26027
26028 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26029 {
26030         if (flags & NDR_IN) {
26031                 if (r->in.handle == NULL) {
26032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26033                 }
26034                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26035         }
26036         if (flags & NDR_OUT) {
26037                 if (r->out.handle == NULL) {
26038                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26039                 }
26040                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26041                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26042         }
26043         return NDR_ERR_SUCCESS;
26044 }
26045
26046 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26047 {
26048         TALLOC_CTX *_mem_save_handle_0;
26049         if (flags & NDR_IN) {
26050                 ZERO_STRUCT(r->out);
26051
26052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26053                         NDR_PULL_ALLOC(ndr, r->in.handle);
26054                 }
26055                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26056                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26057                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26059                 NDR_PULL_ALLOC(ndr, r->out.handle);
26060                 *r->out.handle = *r->in.handle;
26061         }
26062         if (flags & NDR_OUT) {
26063                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26064                         NDR_PULL_ALLOC(ndr, r->out.handle);
26065                 }
26066                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26067                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26068                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26070                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26071         }
26072         return NDR_ERR_SUCCESS;
26073 }
26074
26075 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26076 {
26077         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26078         ndr->depth++;
26079         if (flags & NDR_SET_VALUES) {
26080                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26081         }
26082         if (flags & NDR_IN) {
26083                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26084                 ndr->depth++;
26085                 ndr_print_ptr(ndr, "handle", r->in.handle);
26086                 ndr->depth++;
26087                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26088                 ndr->depth--;
26089                 ndr->depth--;
26090         }
26091         if (flags & NDR_OUT) {
26092                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26093                 ndr->depth++;
26094                 ndr_print_ptr(ndr, "handle", r->out.handle);
26095                 ndr->depth++;
26096                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26097                 ndr->depth--;
26098                 ndr_print_WERROR(ndr, "result", r->out.result);
26099                 ndr->depth--;
26100         }
26101         ndr->depth--;
26102 }
26103
26104 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26105 {
26106         if (flags & NDR_IN) {
26107         }
26108         if (flags & NDR_OUT) {
26109                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26110         }
26111         return NDR_ERR_SUCCESS;
26112 }
26113
26114 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26115 {
26116         if (flags & NDR_IN) {
26117         }
26118         if (flags & NDR_OUT) {
26119                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26120         }
26121         return NDR_ERR_SUCCESS;
26122 }
26123
26124 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26125 {
26126         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
26127         ndr->depth++;
26128         if (flags & NDR_SET_VALUES) {
26129                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26130         }
26131         if (flags & NDR_IN) {
26132                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
26133                 ndr->depth++;
26134                 ndr->depth--;
26135         }
26136         if (flags & NDR_OUT) {
26137                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26138                 ndr->depth++;
26139                 ndr_print_WERROR(ndr, "result", r->out.result);
26140                 ndr->depth--;
26141         }
26142         ndr->depth--;
26143 }
26144
26145 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26146 {
26147         if (flags & NDR_IN) {
26148         }
26149         if (flags & NDR_OUT) {
26150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26151         }
26152         return NDR_ERR_SUCCESS;
26153 }
26154
26155 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26156 {
26157         if (flags & NDR_IN) {
26158         }
26159         if (flags & NDR_OUT) {
26160                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26161         }
26162         return NDR_ERR_SUCCESS;
26163 }
26164
26165 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26166 {
26167         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26168         ndr->depth++;
26169         if (flags & NDR_SET_VALUES) {
26170                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26171         }
26172         if (flags & NDR_IN) {
26173                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26174                 ndr->depth++;
26175                 ndr->depth--;
26176         }
26177         if (flags & NDR_OUT) {
26178                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26179                 ndr->depth++;
26180                 ndr_print_WERROR(ndr, "result", r->out.result);
26181                 ndr->depth--;
26182         }
26183         ndr->depth--;
26184 }
26185
26186 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26187 {
26188         if (flags & NDR_IN) {
26189         }
26190         if (flags & NDR_OUT) {
26191                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26192         }
26193         return NDR_ERR_SUCCESS;
26194 }
26195
26196 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26197 {
26198         if (flags & NDR_IN) {
26199         }
26200         if (flags & NDR_OUT) {
26201                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26202         }
26203         return NDR_ERR_SUCCESS;
26204 }
26205
26206 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26207 {
26208         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26209         ndr->depth++;
26210         if (flags & NDR_SET_VALUES) {
26211                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26212         }
26213         if (flags & NDR_IN) {
26214                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26215                 ndr->depth++;
26216                 ndr->depth--;
26217         }
26218         if (flags & NDR_OUT) {
26219                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26220                 ndr->depth++;
26221                 ndr_print_WERROR(ndr, "result", r->out.result);
26222                 ndr->depth--;
26223         }
26224         ndr->depth--;
26225 }
26226
26227 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
26228 {
26229         if (flags & NDR_IN) {
26230         }
26231         if (flags & NDR_OUT) {
26232                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26233         }
26234         return NDR_ERR_SUCCESS;
26235 }
26236
26237 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
26238 {
26239         if (flags & NDR_IN) {
26240         }
26241         if (flags & NDR_OUT) {
26242                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26243         }
26244         return NDR_ERR_SUCCESS;
26245 }
26246
26247 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
26248 {
26249         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
26250         ndr->depth++;
26251         if (flags & NDR_SET_VALUES) {
26252                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26253         }
26254         if (flags & NDR_IN) {
26255                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
26256                 ndr->depth++;
26257                 ndr->depth--;
26258         }
26259         if (flags & NDR_OUT) {
26260                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26261                 ndr->depth++;
26262                 ndr_print_WERROR(ndr, "result", r->out.result);
26263                 ndr->depth--;
26264         }
26265         ndr->depth--;
26266 }
26267
26268 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26269 {
26270         if (flags & NDR_IN) {
26271                 if (r->in.handle == NULL) {
26272                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26273                 }
26274                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26275                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26277                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26278                 if (r->in.local_machine) {
26279                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26280                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26281                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26282                         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));
26283                 }
26284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26285                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26286                 if (r->in.notify_options) {
26287                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26288                 }
26289         }
26290         if (flags & NDR_OUT) {
26291                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26292         }
26293         return NDR_ERR_SUCCESS;
26294 }
26295
26296 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26297 {
26298         uint32_t _ptr_local_machine;
26299         uint32_t _ptr_notify_options;
26300         TALLOC_CTX *_mem_save_handle_0;
26301         TALLOC_CTX *_mem_save_local_machine_0;
26302         TALLOC_CTX *_mem_save_notify_options_0;
26303         if (flags & NDR_IN) {
26304                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26305                         NDR_PULL_ALLOC(ndr, r->in.handle);
26306                 }
26307                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26308                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26309                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26311                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26313                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26314                 if (_ptr_local_machine) {
26315                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
26316                 } else {
26317                         r->in.local_machine = NULL;
26318                 }
26319                 if (r->in.local_machine) {
26320                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26321                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26322                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26323                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26324                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26325                                 return 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));
26326                         }
26327                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26328                         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));
26329                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26330                 }
26331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26333                 if (_ptr_notify_options) {
26334                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
26335                 } else {
26336                         r->in.notify_options = NULL;
26337                 }
26338                 if (r->in.notify_options) {
26339                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26340                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26341                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26343                 }
26344         }
26345         if (flags & NDR_OUT) {
26346                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26347         }
26348         return NDR_ERR_SUCCESS;
26349 }
26350
26351 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26352 {
26353         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26354         ndr->depth++;
26355         if (flags & NDR_SET_VALUES) {
26356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26357         }
26358         if (flags & NDR_IN) {
26359                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26360                 ndr->depth++;
26361                 ndr_print_ptr(ndr, "handle", r->in.handle);
26362                 ndr->depth++;
26363                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26364                 ndr->depth--;
26365                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26366                 ndr_print_uint32(ndr, "options", r->in.options);
26367                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
26368                 ndr->depth++;
26369                 if (r->in.local_machine) {
26370                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
26371                 }
26372                 ndr->depth--;
26373                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26374                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
26375                 ndr->depth++;
26376                 if (r->in.notify_options) {
26377                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
26378                 }
26379                 ndr->depth--;
26380                 ndr->depth--;
26381         }
26382         if (flags & NDR_OUT) {
26383                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26384                 ndr->depth++;
26385                 ndr_print_WERROR(ndr, "result", r->out.result);
26386                 ndr->depth--;
26387         }
26388         ndr->depth--;
26389 }
26390
26391 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26392 {
26393         if (flags & NDR_IN) {
26394                 if (r->in.handle == NULL) {
26395                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26396                 }
26397                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
26399                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
26401                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26402                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26403         }
26404         if (flags & NDR_OUT) {
26405                 if (r->out.reply_result == NULL) {
26406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26407                 }
26408                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
26409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26410         }
26411         return NDR_ERR_SUCCESS;
26412 }
26413
26414 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
26415 {
26416         TALLOC_CTX *_mem_save_handle_0;
26417         TALLOC_CTX *_mem_save_reply_result_0;
26418         if (flags & NDR_IN) {
26419                 ZERO_STRUCT(r->out);
26420
26421                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26422                         NDR_PULL_ALLOC(ndr, r->in.handle);
26423                 }
26424                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26425                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26426                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
26429                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
26431                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26432                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26433                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
26434                 ZERO_STRUCTP(r->out.reply_result);
26435         }
26436         if (flags & NDR_OUT) {
26437                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26438                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
26439                 }
26440                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
26441                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
26442                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
26443                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
26444                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26445         }
26446         return NDR_ERR_SUCCESS;
26447 }
26448
26449 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26450 {
26451         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
26452         ndr->depth++;
26453         if (flags & NDR_SET_VALUES) {
26454                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26455         }
26456         if (flags & NDR_IN) {
26457                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
26458                 ndr->depth++;
26459                 ndr_print_ptr(ndr, "handle", r->in.handle);
26460                 ndr->depth++;
26461                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26462                 ndr->depth--;
26463                 ndr_print_uint32(ndr, "color", r->in.color);
26464                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26465                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
26466                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
26467                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
26468                 ndr->depth--;
26469         }
26470         if (flags & NDR_OUT) {
26471                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
26472                 ndr->depth++;
26473                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
26474                 ndr->depth++;
26475                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
26476                 ndr->depth--;
26477                 ndr_print_WERROR(ndr, "result", r->out.result);
26478                 ndr->depth--;
26479         }
26480         ndr->depth--;
26481 }
26482
26483 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26484 {
26485         if (flags & NDR_IN) {
26486                 if (r->in.handle == NULL) {
26487                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26488                 }
26489                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
26491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
26492                 if (r->in.options) {
26493                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26494                 }
26495         }
26496         if (flags & NDR_OUT) {
26497                 if (r->out.info == NULL) {
26498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26499                 }
26500                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
26501                 if (*r->out.info) {
26502                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26503                 }
26504                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26505         }
26506         return NDR_ERR_SUCCESS;
26507 }
26508
26509 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
26510 {
26511         uint32_t _ptr_options;
26512         uint32_t _ptr_info;
26513         TALLOC_CTX *_mem_save_handle_0;
26514         TALLOC_CTX *_mem_save_options_0;
26515         TALLOC_CTX *_mem_save_info_0;
26516         TALLOC_CTX *_mem_save_info_1;
26517         if (flags & NDR_IN) {
26518                 ZERO_STRUCT(r->out);
26519
26520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26521                         NDR_PULL_ALLOC(ndr, r->in.handle);
26522                 }
26523                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26524                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26525                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
26528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
26529                 if (_ptr_options) {
26530                         NDR_PULL_ALLOC(ndr, r->in.options);
26531                 } else {
26532                         r->in.options = NULL;
26533                 }
26534                 if (r->in.options) {
26535                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26536                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
26537                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
26539                 }
26540                 NDR_PULL_ALLOC(ndr, r->out.info);
26541                 ZERO_STRUCTP(r->out.info);
26542         }
26543         if (flags & NDR_OUT) {
26544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26545                         NDR_PULL_ALLOC(ndr, r->out.info);
26546                 }
26547                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26548                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26550                 if (_ptr_info) {
26551                         NDR_PULL_ALLOC(ndr, *r->out.info);
26552                 } else {
26553                         *r->out.info = NULL;
26554                 }
26555                 if (*r->out.info) {
26556                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26557                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26558                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26560                 }
26561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26563         }
26564         return NDR_ERR_SUCCESS;
26565 }
26566
26567 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26568 {
26569         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
26570         ndr->depth++;
26571         if (flags & NDR_SET_VALUES) {
26572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26573         }
26574         if (flags & NDR_IN) {
26575                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
26576                 ndr->depth++;
26577                 ndr_print_ptr(ndr, "handle", r->in.handle);
26578                 ndr->depth++;
26579                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26580                 ndr->depth--;
26581                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
26582                 ndr_print_ptr(ndr, "options", r->in.options);
26583                 ndr->depth++;
26584                 if (r->in.options) {
26585                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
26586                 }
26587                 ndr->depth--;
26588                 ndr->depth--;
26589         }
26590         if (flags & NDR_OUT) {
26591                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
26592                 ndr->depth++;
26593                 ndr_print_ptr(ndr, "info", r->out.info);
26594                 ndr->depth++;
26595                 ndr_print_ptr(ndr, "info", *r->out.info);
26596                 ndr->depth++;
26597                 if (*r->out.info) {
26598                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
26599                 }
26600                 ndr->depth--;
26601                 ndr->depth--;
26602                 ndr_print_WERROR(ndr, "result", r->out.result);
26603                 ndr->depth--;
26604         }
26605         ndr->depth--;
26606 }
26607
26608 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
26609 {
26610         if (flags & NDR_IN) {
26611         }
26612         if (flags & NDR_OUT) {
26613                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26614         }
26615         return NDR_ERR_SUCCESS;
26616 }
26617
26618 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
26619 {
26620         if (flags & NDR_IN) {
26621         }
26622         if (flags & NDR_OUT) {
26623                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26624         }
26625         return NDR_ERR_SUCCESS;
26626 }
26627
26628 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
26629 {
26630         ndr_print_struct(ndr, name, "spoolss_44");
26631         ndr->depth++;
26632         if (flags & NDR_SET_VALUES) {
26633                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26634         }
26635         if (flags & NDR_IN) {
26636                 ndr_print_struct(ndr, "in", "spoolss_44");
26637                 ndr->depth++;
26638                 ndr->depth--;
26639         }
26640         if (flags & NDR_OUT) {
26641                 ndr_print_struct(ndr, "out", "spoolss_44");
26642                 ndr->depth++;
26643                 ndr_print_WERROR(ndr, "result", r->out.result);
26644                 ndr->depth--;
26645         }
26646         ndr->depth--;
26647 }
26648
26649 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
26650 {
26651         if (flags & NDR_IN) {
26652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
26653                 if (r->in.printername) {
26654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26658                 }
26659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
26660                 if (r->in.datatype) {
26661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26665                 }
26666                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26667                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
26668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26669                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26670                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26671         }
26672         if (flags & NDR_OUT) {
26673                 if (r->out.handle == NULL) {
26674                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26675                 }
26676                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26677                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26678         }
26679         return NDR_ERR_SUCCESS;
26680 }
26681
26682 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
26683 {
26684         uint32_t _ptr_printername;
26685         uint32_t _ptr_datatype;
26686         TALLOC_CTX *_mem_save_printername_0;
26687         TALLOC_CTX *_mem_save_datatype_0;
26688         TALLOC_CTX *_mem_save_handle_0;
26689         if (flags & NDR_IN) {
26690                 ZERO_STRUCT(r->out);
26691
26692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
26693                 if (_ptr_printername) {
26694                         NDR_PULL_ALLOC(ndr, r->in.printername);
26695                 } else {
26696                         r->in.printername = NULL;
26697                 }
26698                 if (r->in.printername) {
26699                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26700                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
26701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
26702                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
26703                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
26704                                 return 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));
26705                         }
26706                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
26707                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
26708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
26709                 }
26710                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
26711                 if (_ptr_datatype) {
26712                         NDR_PULL_ALLOC(ndr, r->in.datatype);
26713                 } else {
26714                         r->in.datatype = NULL;
26715                 }
26716                 if (r->in.datatype) {
26717                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
26718                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
26719                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
26720                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
26721                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
26722                                 return 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));
26723                         }
26724                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
26725                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
26726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
26727                 }
26728                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26729                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
26730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26731                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26732                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26733                 NDR_PULL_ALLOC(ndr, r->out.handle);
26734                 ZERO_STRUCTP(r->out.handle);
26735         }
26736         if (flags & NDR_OUT) {
26737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26738                         NDR_PULL_ALLOC(ndr, r->out.handle);
26739                 }
26740                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26741                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26742                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26745         }
26746         return NDR_ERR_SUCCESS;
26747 }
26748
26749 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
26750 {
26751         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
26752         ndr->depth++;
26753         if (flags & NDR_SET_VALUES) {
26754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26755         }
26756         if (flags & NDR_IN) {
26757                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
26758                 ndr->depth++;
26759                 ndr_print_ptr(ndr, "printername", r->in.printername);
26760                 ndr->depth++;
26761                 if (r->in.printername) {
26762                         ndr_print_string(ndr, "printername", r->in.printername);
26763                 }
26764                 ndr->depth--;
26765                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
26766                 ndr->depth++;
26767                 if (r->in.datatype) {
26768                         ndr_print_string(ndr, "datatype", r->in.datatype);
26769                 }
26770                 ndr->depth--;
26771                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
26772                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
26773                 ndr_print_uint32(ndr, "level", r->in.level);
26774                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
26775                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
26776                 ndr->depth--;
26777         }
26778         if (flags & NDR_OUT) {
26779                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
26780                 ndr->depth++;
26781                 ndr_print_ptr(ndr, "handle", r->out.handle);
26782                 ndr->depth++;
26783                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26784                 ndr->depth--;
26785                 ndr_print_WERROR(ndr, "result", r->out.result);
26786                 ndr->depth--;
26787         }
26788         ndr->depth--;
26789 }
26790
26791 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
26792 {
26793         if (flags & NDR_IN) {
26794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26795                 if (r->in.server) {
26796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26799                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26800                 }
26801                 if (r->in.info_ctr == NULL) {
26802                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26803                 }
26804                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26805                 if (r->in.devmode_ctr == NULL) {
26806                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26807                 }
26808                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26809                 if (r->in.secdesc_ctr == NULL) {
26810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26811                 }
26812                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26813                 if (r->in.userlevel_ctr == NULL) {
26814                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26815                 }
26816                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26817         }
26818         if (flags & NDR_OUT) {
26819                 if (r->out.handle == NULL) {
26820                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26821                 }
26822                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26823                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26824         }
26825         return NDR_ERR_SUCCESS;
26826 }
26827
26828 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
26829 {
26830         uint32_t _ptr_server;
26831         TALLOC_CTX *_mem_save_server_0;
26832         TALLOC_CTX *_mem_save_info_ctr_0;
26833         TALLOC_CTX *_mem_save_devmode_ctr_0;
26834         TALLOC_CTX *_mem_save_secdesc_ctr_0;
26835         TALLOC_CTX *_mem_save_userlevel_ctr_0;
26836         TALLOC_CTX *_mem_save_handle_0;
26837         if (flags & NDR_IN) {
26838                 ZERO_STRUCT(r->out);
26839
26840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26841                 if (_ptr_server) {
26842                         NDR_PULL_ALLOC(ndr, r->in.server);
26843                 } else {
26844                         r->in.server = NULL;
26845                 }
26846                 if (r->in.server) {
26847                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26848                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26851                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26852                                 return 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));
26853                         }
26854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26857                 }
26858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26859                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26860                 }
26861                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26862                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26863                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26866                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26867                 }
26868                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26869                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26870                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26872                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26873                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
26874                 }
26875                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26876                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
26877                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26878                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26880                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
26881                 }
26882                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26883                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
26884                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26886                 NDR_PULL_ALLOC(ndr, r->out.handle);
26887                 ZERO_STRUCTP(r->out.handle);
26888         }
26889         if (flags & NDR_OUT) {
26890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26891                         NDR_PULL_ALLOC(ndr, r->out.handle);
26892                 }
26893                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26894                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26895                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26898         }
26899         return NDR_ERR_SUCCESS;
26900 }
26901
26902 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
26903 {
26904         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
26905         ndr->depth++;
26906         if (flags & NDR_SET_VALUES) {
26907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26908         }
26909         if (flags & NDR_IN) {
26910                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
26911                 ndr->depth++;
26912                 ndr_print_ptr(ndr, "server", r->in.server);
26913                 ndr->depth++;
26914                 if (r->in.server) {
26915                         ndr_print_string(ndr, "server", r->in.server);
26916                 }
26917                 ndr->depth--;
26918                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26919                 ndr->depth++;
26920                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26921                 ndr->depth--;
26922                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26923                 ndr->depth++;
26924                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26925                 ndr->depth--;
26926                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26927                 ndr->depth++;
26928                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26929                 ndr->depth--;
26930                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26931                 ndr->depth++;
26932                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26933                 ndr->depth--;
26934                 ndr->depth--;
26935         }
26936         if (flags & NDR_OUT) {
26937                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
26938                 ndr->depth++;
26939                 ndr_print_ptr(ndr, "handle", r->out.handle);
26940                 ndr->depth++;
26941                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26942                 ndr->depth--;
26943                 ndr_print_WERROR(ndr, "result", r->out.result);
26944                 ndr->depth--;
26945         }
26946         ndr->depth--;
26947 }
26948
26949 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
26950 {
26951         if (flags & NDR_IN) {
26952         }
26953         if (flags & NDR_OUT) {
26954                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26955         }
26956         return NDR_ERR_SUCCESS;
26957 }
26958
26959 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
26960 {
26961         if (flags & NDR_IN) {
26962         }
26963         if (flags & NDR_OUT) {
26964                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26965         }
26966         return NDR_ERR_SUCCESS;
26967 }
26968
26969 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
26970 {
26971         ndr_print_struct(ndr, name, "spoolss_47");
26972         ndr->depth++;
26973         if (flags & NDR_SET_VALUES) {
26974                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26975         }
26976         if (flags & NDR_IN) {
26977                 ndr_print_struct(ndr, "in", "spoolss_47");
26978                 ndr->depth++;
26979                 ndr->depth--;
26980         }
26981         if (flags & NDR_OUT) {
26982                 ndr_print_struct(ndr, "out", "spoolss_47");
26983                 ndr->depth++;
26984                 ndr_print_WERROR(ndr, "result", r->out.result);
26985                 ndr->depth--;
26986         }
26987         ndr->depth--;
26988 }
26989
26990 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
26991 {
26992         if (flags & NDR_IN) {
26993                 if (r->in.handle == NULL) {
26994                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26995                 }
26996                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
26998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
26999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27000         }
27001         if (flags & NDR_OUT) {
27002                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27003                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27004                 if (r->out.value_needed == NULL) {
27005                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27006                 }
27007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27008                 if (r->out.type == NULL) {
27009                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27010                 }
27011                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27012                 {
27013                         uint32_t _flags_save_uint8 = ndr->flags;
27014                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27015                         if (r->out.data == NULL) {
27016                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27017                         }
27018                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27019                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27020                         ndr->flags = _flags_save_uint8;
27021                 }
27022                 if (r->out.data_needed == NULL) {
27023                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27024                 }
27025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27026                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27027         }
27028         return NDR_ERR_SUCCESS;
27029 }
27030
27031 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27032 {
27033         TALLOC_CTX *_mem_save_handle_0;
27034         TALLOC_CTX *_mem_save_value_needed_0;
27035         TALLOC_CTX *_mem_save_type_0;
27036         TALLOC_CTX *_mem_save_data_needed_0;
27037         if (flags & NDR_IN) {
27038                 ZERO_STRUCT(r->out);
27039
27040                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27041                         NDR_PULL_ALLOC(ndr, r->in.handle);
27042                 }
27043                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27044                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27045                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27046                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27050                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27051                 ZERO_STRUCTP(r->out.value_needed);
27052                 NDR_PULL_ALLOC(ndr, r->out.type);
27053                 ZERO_STRUCTP(r->out.type);
27054                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27055                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27056                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27057                 ZERO_STRUCTP(r->out.data_needed);
27058         }
27059         if (flags & NDR_OUT) {
27060                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27061                 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));
27062                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27063                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27064                 }
27065                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27066                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27070                         NDR_PULL_ALLOC(ndr, r->out.type);
27071                 }
27072                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27073                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27074                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27076                 {
27077                         uint32_t _flags_save_uint8 = ndr->flags;
27078                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27080                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27081                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27082                         }
27083                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27084                         ndr->flags = _flags_save_uint8;
27085                 }
27086                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27087                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27088                 }
27089                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27090                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27092                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27094                 if (r->out.value_name) {
27095                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27096                 }
27097                 if (r->out.data) {
27098                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27099                 }
27100         }
27101         return NDR_ERR_SUCCESS;
27102 }
27103
27104 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27105 {
27106         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27107         ndr->depth++;
27108         if (flags & NDR_SET_VALUES) {
27109                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27110         }
27111         if (flags & NDR_IN) {
27112                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27113                 ndr->depth++;
27114                 ndr_print_ptr(ndr, "handle", r->in.handle);
27115                 ndr->depth++;
27116                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27117                 ndr->depth--;
27118                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27119                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27120                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27121                 ndr->depth--;
27122         }
27123         if (flags & NDR_OUT) {
27124                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27125                 ndr->depth++;
27126                 ndr_print_string(ndr, "value_name", r->out.value_name);
27127                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27128                 ndr->depth++;
27129                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27130                 ndr->depth--;
27131                 ndr_print_ptr(ndr, "type", r->out.type);
27132                 ndr->depth++;
27133                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27134                 ndr->depth--;
27135                 ndr_print_ptr(ndr, "data", r->out.data);
27136                 ndr->depth++;
27137                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27138                 ndr->depth--;
27139                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27140                 ndr->depth++;
27141                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27142                 ndr->depth--;
27143                 ndr_print_WERROR(ndr, "result", r->out.result);
27144                 ndr->depth--;
27145         }
27146         ndr->depth--;
27147 }
27148
27149 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27150 {
27151         if (flags & NDR_IN) {
27152                 if (r->in.handle == NULL) {
27153                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27154                 }
27155                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27156                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27157                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27158                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27159                 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));
27160         }
27161         if (flags & NDR_OUT) {
27162                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27163         }
27164         return NDR_ERR_SUCCESS;
27165 }
27166
27167 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27168 {
27169         TALLOC_CTX *_mem_save_handle_0;
27170         if (flags & NDR_IN) {
27171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27172                         NDR_PULL_ALLOC(ndr, r->in.handle);
27173                 }
27174                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27175                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27176                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27178                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27179                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27180                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27181                         return 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));
27182                 }
27183                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27184                 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));
27185         }
27186         if (flags & NDR_OUT) {
27187                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27188         }
27189         return NDR_ERR_SUCCESS;
27190 }
27191
27192 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27193 {
27194         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27195         ndr->depth++;
27196         if (flags & NDR_SET_VALUES) {
27197                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27198         }
27199         if (flags & NDR_IN) {
27200                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27201                 ndr->depth++;
27202                 ndr_print_ptr(ndr, "handle", r->in.handle);
27203                 ndr->depth++;
27204                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27205                 ndr->depth--;
27206                 ndr_print_string(ndr, "value_name", r->in.value_name);
27207                 ndr->depth--;
27208         }
27209         if (flags & NDR_OUT) {
27210                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27211                 ndr->depth++;
27212                 ndr_print_WERROR(ndr, "result", r->out.result);
27213                 ndr->depth--;
27214         }
27215         ndr->depth--;
27216 }
27217
27218 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27219 {
27220         if (flags & NDR_IN) {
27221         }
27222         if (flags & NDR_OUT) {
27223                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27224         }
27225         return NDR_ERR_SUCCESS;
27226 }
27227
27228 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
27229 {
27230         if (flags & NDR_IN) {
27231         }
27232         if (flags & NDR_OUT) {
27233                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27234         }
27235         return NDR_ERR_SUCCESS;
27236 }
27237
27238 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
27239 {
27240         ndr_print_struct(ndr, name, "spoolss_4a");
27241         ndr->depth++;
27242         if (flags & NDR_SET_VALUES) {
27243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27244         }
27245         if (flags & NDR_IN) {
27246                 ndr_print_struct(ndr, "in", "spoolss_4a");
27247                 ndr->depth++;
27248                 ndr->depth--;
27249         }
27250         if (flags & NDR_OUT) {
27251                 ndr_print_struct(ndr, "out", "spoolss_4a");
27252                 ndr->depth++;
27253                 ndr_print_WERROR(ndr, "result", r->out.result);
27254                 ndr->depth--;
27255         }
27256         ndr->depth--;
27257 }
27258
27259 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27260 {
27261         if (flags & NDR_IN) {
27262         }
27263         if (flags & NDR_OUT) {
27264                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27265         }
27266         return NDR_ERR_SUCCESS;
27267 }
27268
27269 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27270 {
27271         if (flags & NDR_IN) {
27272         }
27273         if (flags & NDR_OUT) {
27274                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27275         }
27276         return NDR_ERR_SUCCESS;
27277 }
27278
27279 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27280 {
27281         ndr_print_struct(ndr, name, "spoolss_4b");
27282         ndr->depth++;
27283         if (flags & NDR_SET_VALUES) {
27284                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27285         }
27286         if (flags & NDR_IN) {
27287                 ndr_print_struct(ndr, "in", "spoolss_4b");
27288                 ndr->depth++;
27289                 ndr->depth--;
27290         }
27291         if (flags & NDR_OUT) {
27292                 ndr_print_struct(ndr, "out", "spoolss_4b");
27293                 ndr->depth++;
27294                 ndr_print_WERROR(ndr, "result", r->out.result);
27295                 ndr->depth--;
27296         }
27297         ndr->depth--;
27298 }
27299
27300 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27301 {
27302         if (flags & NDR_IN) {
27303         }
27304         if (flags & NDR_OUT) {
27305                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27306         }
27307         return NDR_ERR_SUCCESS;
27308 }
27309
27310 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27311 {
27312         if (flags & NDR_IN) {
27313         }
27314         if (flags & NDR_OUT) {
27315                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27316         }
27317         return NDR_ERR_SUCCESS;
27318 }
27319
27320 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27321 {
27322         ndr_print_struct(ndr, name, "spoolss_4c");
27323         ndr->depth++;
27324         if (flags & NDR_SET_VALUES) {
27325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27326         }
27327         if (flags & NDR_IN) {
27328                 ndr_print_struct(ndr, "in", "spoolss_4c");
27329                 ndr->depth++;
27330                 ndr->depth--;
27331         }
27332         if (flags & NDR_OUT) {
27333                 ndr_print_struct(ndr, "out", "spoolss_4c");
27334                 ndr->depth++;
27335                 ndr_print_WERROR(ndr, "result", r->out.result);
27336                 ndr->depth--;
27337         }
27338         ndr->depth--;
27339 }
27340
27341 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterDataEx *r)
27342 {
27343         if (flags & NDR_IN) {
27344                 if (r->in.handle == NULL) {
27345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27346                 }
27347                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27348                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27349                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27350                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27351                 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));
27352                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27353                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27354                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27355                 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));
27356                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27357                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
27358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
27359         }
27360         if (flags & NDR_OUT) {
27361                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27362         }
27363         return NDR_ERR_SUCCESS;
27364 }
27365
27366 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterDataEx *r)
27367 {
27368         if (flags & NDR_IN) {
27369                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27370         }
27371         if (flags & NDR_OUT) {
27372                 if (r->out.data == NULL) {
27373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27374                 }
27375                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
27376                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
27377         }
27378         return NDR_ERR_SUCCESS;
27379 }
27380
27381 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
27382 {
27383         TALLOC_CTX *_mem_save_handle_0;
27384         if (flags & NDR_IN) {
27385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27386                         NDR_PULL_ALLOC(ndr, r->in.handle);
27387                 }
27388                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27389                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27390                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27392                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27393                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27394                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27395                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
27396                 }
27397                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27398                 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));
27399                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27400                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27401                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27402                         return 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));
27403                 }
27404                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27405                 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));
27406                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27407                 {
27408                         struct ndr_pull *_ndr_data;
27409                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
27410                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
27411                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
27412                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
27413                 }
27414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
27415         }
27416         if (flags & NDR_OUT) {
27417                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27418         }
27419         return NDR_ERR_SUCCESS;
27420 }
27421
27422 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
27423 {
27424         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
27425         ndr->depth++;
27426         if (flags & NDR_SET_VALUES) {
27427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27428         }
27429         if (flags & NDR_IN) {
27430                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
27431                 ndr->depth++;
27432                 ndr_print_ptr(ndr, "handle", r->in.handle);
27433                 ndr->depth++;
27434                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27435                 ndr->depth--;
27436                 ndr_print_string(ndr, "key_name", r->in.key_name);
27437                 ndr_print_string(ndr, "value_name", r->in.value_name);
27438                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27439                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
27440                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
27441                 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);
27442                 ndr->depth--;
27443         }
27444         if (flags & NDR_OUT) {
27445                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
27446                 ndr->depth++;
27447                 ndr_print_WERROR(ndr, "result", r->out.result);
27448                 ndr->depth--;
27449         }
27450         ndr->depth--;
27451 }
27452
27453 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterDataEx *r)
27454 {
27455         if (flags & NDR_IN) {
27456                 if (r->in.handle == NULL) {
27457                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27458                 }
27459                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27460                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27461                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27462                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27463                 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));
27464                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27465                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27466                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27467                 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));
27468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27469         }
27470         if (flags & NDR_OUT) {
27471                 if (r->out.type == NULL) {
27472                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27473                 }
27474                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27475                 if (r->out.data == NULL) {
27476                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27477                 }
27478                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
27479                 if (r->out.needed == NULL) {
27480                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27481                 }
27482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27483                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27484         }
27485         return NDR_ERR_SUCCESS;
27486 }
27487
27488 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterDataEx *r)
27489 {
27490         TALLOC_CTX *_mem_save_handle_0;
27491         TALLOC_CTX *_mem_save_type_0;
27492         TALLOC_CTX *_mem_save_data_0;
27493         TALLOC_CTX *_mem_save_needed_0;
27494         if (flags & NDR_IN) {
27495                 ZERO_STRUCT(r->out);
27496
27497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27498                         NDR_PULL_ALLOC(ndr, r->in.handle);
27499                 }
27500                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27501                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27502                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27504                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27505                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27506                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27507                         return 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));
27508                 }
27509                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27510                 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));
27511                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27512                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27513                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27514                         return 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));
27515                 }
27516                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27517                 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));
27518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27519                 NDR_PULL_ALLOC(ndr, r->out.type);
27520                 ZERO_STRUCTP(r->out.type);
27521                 NDR_PULL_ALLOC(ndr, r->out.data);
27522                 ZERO_STRUCTP(r->out.data);
27523                 NDR_PULL_ALLOC(ndr, r->out.needed);
27524                 ZERO_STRUCTP(r->out.needed);
27525         }
27526         if (flags & NDR_OUT) {
27527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27528                         NDR_PULL_ALLOC(ndr, r->out.type);
27529                 }
27530                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27531                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27532                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27534                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27535                         NDR_PULL_ALLOC(ndr, r->out.data);
27536                 }
27537                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
27538                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
27539                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
27540                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
27541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27542                         NDR_PULL_ALLOC(ndr, r->out.needed);
27543                 }
27544                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27545                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27548                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27549         }
27550         return NDR_ERR_SUCCESS;
27551 }
27552
27553 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterDataEx *r)
27554 {
27555         if (flags & NDR_IN) {
27556                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27557         }
27558         if (flags & NDR_OUT) {
27559                 if (r->out.data == NULL) {
27560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27561                 }
27562                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
27563                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
27564         }
27565         return NDR_ERR_SUCCESS;
27566 }
27567
27568 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterDataEx *r)
27569 {
27570         TALLOC_CTX *_mem_save_data_0;
27571         if (flags & NDR_IN) {
27572                 ZERO_STRUCT(r->out);
27573
27574                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27575                 NDR_PULL_ALLOC(ndr, r->out.data);
27576                 ZERO_STRUCTP(r->out.data);
27577         }
27578         if (flags & NDR_OUT) {
27579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27580                         NDR_PULL_ALLOC(ndr, r->out.data);
27581                 }
27582                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
27583                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
27584                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
27585                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
27586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
27587         }
27588         return NDR_ERR_SUCCESS;
27589 }
27590
27591 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
27592 {
27593         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
27594         ndr->depth++;
27595         if (flags & NDR_SET_VALUES) {
27596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27597         }
27598         if (flags & NDR_IN) {
27599                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
27600                 ndr->depth++;
27601                 ndr_print_ptr(ndr, "handle", r->in.handle);
27602                 ndr->depth++;
27603                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27604                 ndr->depth--;
27605                 ndr_print_string(ndr, "key_name", r->in.key_name);
27606                 ndr_print_string(ndr, "value_name", r->in.value_name);
27607                 ndr_print_uint32(ndr, "offered", r->in.offered);
27608                 ndr->depth--;
27609         }
27610         if (flags & NDR_OUT) {
27611                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
27612                 ndr->depth++;
27613                 ndr_print_ptr(ndr, "type", r->out.type);
27614                 ndr->depth++;
27615                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27616                 ndr->depth--;
27617                 ndr_print_ptr(ndr, "data", r->out.data);
27618                 ndr->depth++;
27619                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
27620                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
27621                 ndr->depth--;
27622                 ndr_print_ptr(ndr, "needed", r->out.needed);
27623                 ndr->depth++;
27624                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27625                 ndr->depth--;
27626                 ndr_print_WERROR(ndr, "result", r->out.result);
27627                 ndr->depth--;
27628         }
27629         ndr->depth--;
27630 }
27631
27632 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
27633 {
27634         if (flags & NDR_IN) {
27635                 if (r->in.handle == NULL) {
27636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27637                 }
27638                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27639                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27640                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27641                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27642                 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));
27643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27644         }
27645         if (flags & NDR_OUT) {
27646                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
27647                 if (r->out.needed == NULL) {
27648                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27649                 }
27650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27651                 if (r->out.count == NULL) {
27652                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27653                 }
27654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
27655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27656         }
27657         return NDR_ERR_SUCCESS;
27658 }
27659
27660 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
27661 {
27662         TALLOC_CTX *_mem_save_handle_0;
27663         TALLOC_CTX *_mem_save_needed_0;
27664         TALLOC_CTX *_mem_save_count_0;
27665         if (flags & NDR_IN) {
27666                 ZERO_STRUCT(r->out);
27667
27668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27669                         NDR_PULL_ALLOC(ndr, r->in.handle);
27670                 }
27671                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27672                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27673                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27675                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27676                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27677                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27678                         return 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));
27679                 }
27680                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27681                 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));
27682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27683                 NDR_PULL_ALLOC(ndr, r->out.needed);
27684                 ZERO_STRUCTP(r->out.needed);
27685                 NDR_PULL_ALLOC(ndr, r->out.count);
27686                 ZERO_STRUCTP(r->out.count);
27687         }
27688         if (flags & NDR_OUT) {
27689                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
27690                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27691                         NDR_PULL_ALLOC(ndr, r->out.needed);
27692                 }
27693                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27694                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27696                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27697                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27698                         NDR_PULL_ALLOC(ndr, r->out.count);
27699                 }
27700                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
27701                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
27702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
27703                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
27704                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27705         }
27706         return NDR_ERR_SUCCESS;
27707 }
27708
27709 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
27710 {
27711         uint32_t cntr_info_0;
27712         if (flags & NDR_IN) {
27713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
27714         }
27715         if (flags & NDR_OUT) {
27716                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27717                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27718                 }
27719                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27720                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27721                 }
27722         }
27723         return NDR_ERR_SUCCESS;
27724 }
27725
27726 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
27727 {
27728         uint32_t cntr_info_0;
27729         TALLOC_CTX *_mem_save_info_0;
27730         if (flags & NDR_IN) {
27731                 ZERO_STRUCT(r->out);
27732
27733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
27734         }
27735         if (flags & NDR_OUT) {
27736                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
27737                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27738                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
27739                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27740                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27741                 }
27742                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27743                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27744                 }
27745                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
27746         }
27747         return NDR_ERR_SUCCESS;
27748 }
27749
27750 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
27751 {
27752         uint32_t cntr_info_2;
27753         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
27754         ndr->depth++;
27755         if (flags & NDR_SET_VALUES) {
27756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27757         }
27758         if (flags & NDR_IN) {
27759                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
27760                 ndr->depth++;
27761                 ndr_print_ptr(ndr, "handle", r->in.handle);
27762                 ndr->depth++;
27763                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27764                 ndr->depth--;
27765                 ndr_print_string(ndr, "key_name", r->in.key_name);
27766                 ndr_print_uint32(ndr, "offered", r->in.offered);
27767                 ndr->depth--;
27768         }
27769         if (flags & NDR_OUT) {
27770                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
27771                 ndr->depth++;
27772                 ndr_print_ptr(ndr, "count", r->out.count);
27773                 ndr->depth++;
27774                 ndr_print_uint32(ndr, "count", *r->out.count);
27775                 ndr->depth--;
27776                 ndr_print_ptr(ndr, "info", r->out.info);
27777                 ndr->depth++;
27778                 ndr_print_ptr(ndr, "info", *r->out.info);
27779                 ndr->depth++;
27780                 if (*r->out.info) {
27781                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
27782                         ndr->depth++;
27783                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
27784                                 char *idx_2=NULL;
27785                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
27786                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
27787                                         free(idx_2);
27788                                 }
27789                         }
27790                         ndr->depth--;
27791                 }
27792                 ndr->depth--;
27793                 ndr->depth--;
27794                 ndr_print_ptr(ndr, "needed", r->out.needed);
27795                 ndr->depth++;
27796                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27797                 ndr->depth--;
27798                 ndr_print_WERROR(ndr, "result", r->out.result);
27799                 ndr->depth--;
27800         }
27801         ndr->depth--;
27802 }
27803
27804 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
27805 {
27806         if (flags & NDR_IN) {
27807                 if (r->in.handle == NULL) {
27808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27809                 }
27810                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27811                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27812                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27813                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27814                 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));
27815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27816         }
27817         if (flags & NDR_OUT) {
27818                 if (r->out._ndr_size == NULL) {
27819                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27820                 }
27821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
27822                 if (r->out.key_buffer == NULL) {
27823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27824                 }
27825                 {
27826                         struct ndr_push *_ndr_key_buffer;
27827                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
27828                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
27829                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
27830                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
27831                 }
27832                 if (r->out.needed == NULL) {
27833                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27834                 }
27835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27836                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27837         }
27838         return NDR_ERR_SUCCESS;
27839 }
27840
27841 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
27842 {
27843         TALLOC_CTX *_mem_save_handle_0;
27844         TALLOC_CTX *_mem_save__ndr_size_0;
27845         TALLOC_CTX *_mem_save_key_buffer_0;
27846         TALLOC_CTX *_mem_save_needed_0;
27847         if (flags & NDR_IN) {
27848                 ZERO_STRUCT(r->out);
27849
27850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27851                         NDR_PULL_ALLOC(ndr, r->in.handle);
27852                 }
27853                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27854                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27855                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27857                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27858                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27859                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27860                         return 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));
27861                 }
27862                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27863                 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));
27864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27865                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
27866                 ZERO_STRUCTP(r->out._ndr_size);
27867                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27868                 ZERO_STRUCTP(r->out.key_buffer);
27869                 NDR_PULL_ALLOC(ndr, r->out.needed);
27870                 ZERO_STRUCTP(r->out.needed);
27871         }
27872         if (flags & NDR_OUT) {
27873                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27874                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
27875                 }
27876                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
27877                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
27878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
27879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
27880                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27881                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27882                 }
27883                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27884                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
27885                 {
27886                         struct ndr_pull *_ndr_key_buffer;
27887                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
27888                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
27889                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
27890                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
27891                 }
27892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
27893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27894                         NDR_PULL_ALLOC(ndr, r->out.needed);
27895                 }
27896                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27897                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27900                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27901         }
27902         return NDR_ERR_SUCCESS;
27903 }
27904
27905 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
27906 {
27907         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
27908         ndr->depth++;
27909         if (flags & NDR_SET_VALUES) {
27910                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27911         }
27912         if (flags & NDR_IN) {
27913                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
27914                 ndr->depth++;
27915                 ndr_print_ptr(ndr, "handle", r->in.handle);
27916                 ndr->depth++;
27917                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27918                 ndr->depth--;
27919                 ndr_print_string(ndr, "key_name", r->in.key_name);
27920                 ndr_print_uint32(ndr, "offered", r->in.offered);
27921                 ndr->depth--;
27922         }
27923         if (flags & NDR_OUT) {
27924                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
27925                 ndr->depth++;
27926                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
27927                 ndr->depth++;
27928                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
27929                 ndr->depth--;
27930                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
27931                 ndr->depth++;
27932                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
27933                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
27934                 ndr->depth--;
27935                 ndr_print_ptr(ndr, "needed", r->out.needed);
27936                 ndr->depth++;
27937                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27938                 ndr->depth--;
27939                 ndr_print_WERROR(ndr, "result", r->out.result);
27940                 ndr->depth--;
27941         }
27942         ndr->depth--;
27943 }
27944
27945 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
27946 {
27947         if (flags & NDR_IN) {
27948                 if (r->in.handle == NULL) {
27949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27950                 }
27951                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27952                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27953                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27954                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27955                 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));
27956                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27957                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27958                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27959                 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));
27960         }
27961         if (flags & NDR_OUT) {
27962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27963         }
27964         return NDR_ERR_SUCCESS;
27965 }
27966
27967 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
27968 {
27969         TALLOC_CTX *_mem_save_handle_0;
27970         if (flags & NDR_IN) {
27971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27972                         NDR_PULL_ALLOC(ndr, r->in.handle);
27973                 }
27974                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27975                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27976                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27977                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27978                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27979                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27980                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27981                         return 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));
27982                 }
27983                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27984                 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));
27985                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27986                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27987                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27988                         return 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));
27989                 }
27990                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27991                 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));
27992         }
27993         if (flags & NDR_OUT) {
27994                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27995         }
27996         return NDR_ERR_SUCCESS;
27997 }
27998
27999 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28000 {
28001         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28002         ndr->depth++;
28003         if (flags & NDR_SET_VALUES) {
28004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28005         }
28006         if (flags & NDR_IN) {
28007                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28008                 ndr->depth++;
28009                 ndr_print_ptr(ndr, "handle", r->in.handle);
28010                 ndr->depth++;
28011                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28012                 ndr->depth--;
28013                 ndr_print_string(ndr, "key_name", r->in.key_name);
28014                 ndr_print_string(ndr, "value_name", r->in.value_name);
28015                 ndr->depth--;
28016         }
28017         if (flags & NDR_OUT) {
28018                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28019                 ndr->depth++;
28020                 ndr_print_WERROR(ndr, "result", r->out.result);
28021                 ndr->depth--;
28022         }
28023         ndr->depth--;
28024 }
28025
28026 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28027 {
28028         if (flags & NDR_IN) {
28029                 if (r->in.handle == NULL) {
28030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28031                 }
28032                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28033                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28034                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28035                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28036                 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));
28037         }
28038         if (flags & NDR_OUT) {
28039                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28040         }
28041         return NDR_ERR_SUCCESS;
28042 }
28043
28044 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28045 {
28046         TALLOC_CTX *_mem_save_handle_0;
28047         if (flags & NDR_IN) {
28048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28049                         NDR_PULL_ALLOC(ndr, r->in.handle);
28050                 }
28051                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28052                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28053                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28055                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28056                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28057                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28058                         return 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));
28059                 }
28060                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28061                 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));
28062         }
28063         if (flags & NDR_OUT) {
28064                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28065         }
28066         return NDR_ERR_SUCCESS;
28067 }
28068
28069 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28070 {
28071         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28072         ndr->depth++;
28073         if (flags & NDR_SET_VALUES) {
28074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28075         }
28076         if (flags & NDR_IN) {
28077                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28078                 ndr->depth++;
28079                 ndr_print_ptr(ndr, "handle", r->in.handle);
28080                 ndr->depth++;
28081                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28082                 ndr->depth--;
28083                 ndr_print_string(ndr, "key_name", r->in.key_name);
28084                 ndr->depth--;
28085         }
28086         if (flags & NDR_OUT) {
28087                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28088                 ndr->depth++;
28089                 ndr_print_WERROR(ndr, "result", r->out.result);
28090                 ndr->depth--;
28091         }
28092         ndr->depth--;
28093 }
28094
28095 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28096 {
28097         if (flags & NDR_IN) {
28098         }
28099         if (flags & NDR_OUT) {
28100                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28101         }
28102         return NDR_ERR_SUCCESS;
28103 }
28104
28105 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28106 {
28107         if (flags & NDR_IN) {
28108         }
28109         if (flags & NDR_OUT) {
28110                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28111         }
28112         return NDR_ERR_SUCCESS;
28113 }
28114
28115 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28116 {
28117         ndr_print_struct(ndr, name, "spoolss_53");
28118         ndr->depth++;
28119         if (flags & NDR_SET_VALUES) {
28120                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28121         }
28122         if (flags & NDR_IN) {
28123                 ndr_print_struct(ndr, "in", "spoolss_53");
28124                 ndr->depth++;
28125                 ndr->depth--;
28126         }
28127         if (flags & NDR_OUT) {
28128                 ndr_print_struct(ndr, "out", "spoolss_53");
28129                 ndr->depth++;
28130                 ndr_print_WERROR(ndr, "result", r->out.result);
28131                 ndr->depth--;
28132         }
28133         ndr->depth--;
28134 }
28135
28136 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28137 {
28138         if (flags & NDR_IN) {
28139                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28140                 if (r->in.server) {
28141                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28144                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28145                 }
28146                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28147                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28148                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28149                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28150                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28151                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28152                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28153                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28154                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28156         }
28157         if (flags & NDR_OUT) {
28158                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28159         }
28160         return NDR_ERR_SUCCESS;
28161 }
28162
28163 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28164 {
28165         uint32_t _ptr_server;
28166         TALLOC_CTX *_mem_save_server_0;
28167         if (flags & NDR_IN) {
28168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28169                 if (_ptr_server) {
28170                         NDR_PULL_ALLOC(ndr, r->in.server);
28171                 } else {
28172                         r->in.server = NULL;
28173                 }
28174                 if (r->in.server) {
28175                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28176                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28178                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28179                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28180                                 return 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));
28181                         }
28182                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28183                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28185                 }
28186                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28187                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28188                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28189                         return 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));
28190                 }
28191                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28192                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28193                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28194                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28195                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28196                         return 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));
28197                 }
28198                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28199                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28200                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28202         }
28203         if (flags & NDR_OUT) {
28204                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28205         }
28206         return NDR_ERR_SUCCESS;
28207 }
28208
28209 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28210 {
28211         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28212         ndr->depth++;
28213         if (flags & NDR_SET_VALUES) {
28214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28215         }
28216         if (flags & NDR_IN) {
28217                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28218                 ndr->depth++;
28219                 ndr_print_ptr(ndr, "server", r->in.server);
28220                 ndr->depth++;
28221                 if (r->in.server) {
28222                         ndr_print_string(ndr, "server", r->in.server);
28223                 }
28224                 ndr->depth--;
28225                 ndr_print_string(ndr, "architecture", r->in.architecture);
28226                 ndr_print_string(ndr, "driver", r->in.driver);
28227                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
28228                 ndr_print_uint32(ndr, "version", r->in.version);
28229                 ndr->depth--;
28230         }
28231         if (flags & NDR_OUT) {
28232                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
28233                 ndr->depth++;
28234                 ndr_print_WERROR(ndr, "result", r->out.result);
28235                 ndr->depth--;
28236         }
28237         ndr->depth--;
28238 }
28239
28240 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
28241 {
28242         if (flags & NDR_IN) {
28243         }
28244         if (flags & NDR_OUT) {
28245                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28246         }
28247         return NDR_ERR_SUCCESS;
28248 }
28249
28250 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
28251 {
28252         if (flags & NDR_IN) {
28253         }
28254         if (flags & NDR_OUT) {
28255                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28256         }
28257         return NDR_ERR_SUCCESS;
28258 }
28259
28260 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
28261 {
28262         ndr_print_struct(ndr, name, "spoolss_55");
28263         ndr->depth++;
28264         if (flags & NDR_SET_VALUES) {
28265                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28266         }
28267         if (flags & NDR_IN) {
28268                 ndr_print_struct(ndr, "in", "spoolss_55");
28269                 ndr->depth++;
28270                 ndr->depth--;
28271         }
28272         if (flags & NDR_OUT) {
28273                 ndr_print_struct(ndr, "out", "spoolss_55");
28274                 ndr->depth++;
28275                 ndr_print_WERROR(ndr, "result", r->out.result);
28276                 ndr->depth--;
28277         }
28278         ndr->depth--;
28279 }
28280
28281 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
28282 {
28283         if (flags & NDR_IN) {
28284         }
28285         if (flags & NDR_OUT) {
28286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28287         }
28288         return NDR_ERR_SUCCESS;
28289 }
28290
28291 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
28292 {
28293         if (flags & NDR_IN) {
28294         }
28295         if (flags & NDR_OUT) {
28296                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28297         }
28298         return NDR_ERR_SUCCESS;
28299 }
28300
28301 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28302 {
28303         ndr_print_struct(ndr, name, "spoolss_56");
28304         ndr->depth++;
28305         if (flags & NDR_SET_VALUES) {
28306                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28307         }
28308         if (flags & NDR_IN) {
28309                 ndr_print_struct(ndr, "in", "spoolss_56");
28310                 ndr->depth++;
28311                 ndr->depth--;
28312         }
28313         if (flags & NDR_OUT) {
28314                 ndr_print_struct(ndr, "out", "spoolss_56");
28315                 ndr->depth++;
28316                 ndr_print_WERROR(ndr, "result", r->out.result);
28317                 ndr->depth--;
28318         }
28319         ndr->depth--;
28320 }
28321
28322 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28323 {
28324         if (flags & NDR_IN) {
28325         }
28326         if (flags & NDR_OUT) {
28327                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28328         }
28329         return NDR_ERR_SUCCESS;
28330 }
28331
28332 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28333 {
28334         if (flags & NDR_IN) {
28335         }
28336         if (flags & NDR_OUT) {
28337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28338         }
28339         return NDR_ERR_SUCCESS;
28340 }
28341
28342 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28343 {
28344         ndr_print_struct(ndr, name, "spoolss_57");
28345         ndr->depth++;
28346         if (flags & NDR_SET_VALUES) {
28347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28348         }
28349         if (flags & NDR_IN) {
28350                 ndr_print_struct(ndr, "in", "spoolss_57");
28351                 ndr->depth++;
28352                 ndr->depth--;
28353         }
28354         if (flags & NDR_OUT) {
28355                 ndr_print_struct(ndr, "out", "spoolss_57");
28356                 ndr->depth++;
28357                 ndr_print_WERROR(ndr, "result", r->out.result);
28358                 ndr->depth--;
28359         }
28360         ndr->depth--;
28361 }
28362
28363 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
28364 {
28365         if (flags & NDR_IN) {
28366                 if (r->in.handle == NULL) {
28367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28368                 }
28369                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28370                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28371                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28372                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28373                 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));
28374                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
28375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
28376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28377                 if (r->in.status_code == NULL) {
28378                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28379                 }
28380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
28381         }
28382         if (flags & NDR_OUT) {
28383                 if (r->out.out_data == NULL) {
28384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28385                 }
28386                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
28387                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
28388                 if (r->out.needed == NULL) {
28389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28390                 }
28391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28392                 if (r->out.status_code == NULL) {
28393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28394                 }
28395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
28396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28397         }
28398         return NDR_ERR_SUCCESS;
28399 }
28400
28401 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
28402 {
28403         TALLOC_CTX *_mem_save_handle_0;
28404         TALLOC_CTX *_mem_save_needed_0;
28405         TALLOC_CTX *_mem_save_status_code_0;
28406         if (flags & NDR_IN) {
28407                 ZERO_STRUCT(r->out);
28408
28409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28410                         NDR_PULL_ALLOC(ndr, r->in.handle);
28411                 }
28412                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28413                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28414                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28416                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
28417                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
28418                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
28419                         return 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));
28420                 }
28421                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
28422                 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));
28423                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
28424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
28425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
28426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28427                         NDR_PULL_ALLOC(ndr, r->in.status_code);
28428                 }
28429                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28430                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
28431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
28432                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28433                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
28434                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
28435                 NDR_PULL_ALLOC(ndr, r->out.needed);
28436                 ZERO_STRUCTP(r->out.needed);
28437                 NDR_PULL_ALLOC(ndr, r->out.status_code);
28438                 *r->out.status_code = *r->in.status_code;
28439         }
28440         if (flags & NDR_OUT) {
28441                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
28442                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28443                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
28444                 }
28445                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
28446                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28447                         NDR_PULL_ALLOC(ndr, r->out.needed);
28448                 }
28449                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28450                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28452                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28453                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28454                         NDR_PULL_ALLOC(ndr, r->out.status_code);
28455                 }
28456                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28457                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
28458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
28459                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28461                 if (r->out.out_data) {
28462                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
28463                 }
28464         }
28465         return NDR_ERR_SUCCESS;
28466 }
28467
28468 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
28469 {
28470         ndr_print_struct(ndr, name, "spoolss_XcvData");
28471         ndr->depth++;
28472         if (flags & NDR_SET_VALUES) {
28473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28474         }
28475         if (flags & NDR_IN) {
28476                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
28477                 ndr->depth++;
28478                 ndr_print_ptr(ndr, "handle", r->in.handle);
28479                 ndr->depth++;
28480                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28481                 ndr->depth--;
28482                 ndr_print_string(ndr, "function_name", r->in.function_name);
28483                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
28484                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
28485                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
28486                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
28487                 ndr->depth++;
28488                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
28489                 ndr->depth--;
28490                 ndr->depth--;
28491         }
28492         if (flags & NDR_OUT) {
28493                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
28494                 ndr->depth++;
28495                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
28496                 ndr->depth++;
28497                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
28498                 ndr->depth--;
28499                 ndr_print_ptr(ndr, "needed", r->out.needed);
28500                 ndr->depth++;
28501                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28502                 ndr->depth--;
28503                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
28504                 ndr->depth++;
28505                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
28506                 ndr->depth--;
28507                 ndr_print_WERROR(ndr, "result", r->out.result);
28508                 ndr->depth--;
28509         }
28510         ndr->depth--;
28511 }
28512
28513 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
28514 {
28515         if (flags & NDR_IN) {
28516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28517                 if (r->in.servername) {
28518                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28519                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28520                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28521                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28522                 }
28523                 if (r->in.info_ctr == NULL) {
28524                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28525                 }
28526                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28527                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
28528         }
28529         if (flags & NDR_OUT) {
28530                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28531         }
28532         return NDR_ERR_SUCCESS;
28533 }
28534
28535 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
28536 {
28537         uint32_t _ptr_servername;
28538         TALLOC_CTX *_mem_save_servername_0;
28539         TALLOC_CTX *_mem_save_info_ctr_0;
28540         if (flags & NDR_IN) {
28541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28542                 if (_ptr_servername) {
28543                         NDR_PULL_ALLOC(ndr, r->in.servername);
28544                 } else {
28545                         r->in.servername = NULL;
28546                 }
28547                 if (r->in.servername) {
28548                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28549                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28552                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28553                                 return 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));
28554                         }
28555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28558                 }
28559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28560                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28561                 }
28562                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28563                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28564                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28566                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
28567         }
28568         if (flags & NDR_OUT) {
28569                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28570         }
28571         return NDR_ERR_SUCCESS;
28572 }
28573
28574 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
28575 {
28576         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
28577         ndr->depth++;
28578         if (flags & NDR_SET_VALUES) {
28579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28580         }
28581         if (flags & NDR_IN) {
28582                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
28583                 ndr->depth++;
28584                 ndr_print_ptr(ndr, "servername", r->in.servername);
28585                 ndr->depth++;
28586                 if (r->in.servername) {
28587                         ndr_print_string(ndr, "servername", r->in.servername);
28588                 }
28589                 ndr->depth--;
28590                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28591                 ndr->depth++;
28592                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28593                 ndr->depth--;
28594                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
28595                 ndr->depth--;
28596         }
28597         if (flags & NDR_OUT) {
28598                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
28599                 ndr->depth++;
28600                 ndr_print_WERROR(ndr, "result", r->out.result);
28601                 ndr->depth--;
28602         }
28603         ndr->depth--;
28604 }
28605
28606 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
28607 {
28608         if (flags & NDR_IN) {
28609         }
28610         if (flags & NDR_OUT) {
28611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28612         }
28613         return NDR_ERR_SUCCESS;
28614 }
28615
28616 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
28617 {
28618         if (flags & NDR_IN) {
28619         }
28620         if (flags & NDR_OUT) {
28621                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28622         }
28623         return NDR_ERR_SUCCESS;
28624 }
28625
28626 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
28627 {
28628         ndr_print_struct(ndr, name, "spoolss_5a");
28629         ndr->depth++;
28630         if (flags & NDR_SET_VALUES) {
28631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28632         }
28633         if (flags & NDR_IN) {
28634                 ndr_print_struct(ndr, "in", "spoolss_5a");
28635                 ndr->depth++;
28636                 ndr->depth--;
28637         }
28638         if (flags & NDR_OUT) {
28639                 ndr_print_struct(ndr, "out", "spoolss_5a");
28640                 ndr->depth++;
28641                 ndr_print_WERROR(ndr, "result", r->out.result);
28642                 ndr->depth--;
28643         }
28644         ndr->depth--;
28645 }
28646
28647 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
28648 {
28649         if (flags & NDR_IN) {
28650         }
28651         if (flags & NDR_OUT) {
28652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28653         }
28654         return NDR_ERR_SUCCESS;
28655 }
28656
28657 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
28658 {
28659         if (flags & NDR_IN) {
28660         }
28661         if (flags & NDR_OUT) {
28662                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28663         }
28664         return NDR_ERR_SUCCESS;
28665 }
28666
28667 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
28668 {
28669         ndr_print_struct(ndr, name, "spoolss_5b");
28670         ndr->depth++;
28671         if (flags & NDR_SET_VALUES) {
28672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28673         }
28674         if (flags & NDR_IN) {
28675                 ndr_print_struct(ndr, "in", "spoolss_5b");
28676                 ndr->depth++;
28677                 ndr->depth--;
28678         }
28679         if (flags & NDR_OUT) {
28680                 ndr_print_struct(ndr, "out", "spoolss_5b");
28681                 ndr->depth++;
28682                 ndr_print_WERROR(ndr, "result", r->out.result);
28683                 ndr->depth--;
28684         }
28685         ndr->depth--;
28686 }
28687
28688 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
28689 {
28690         if (flags & NDR_IN) {
28691         }
28692         if (flags & NDR_OUT) {
28693                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28694         }
28695         return NDR_ERR_SUCCESS;
28696 }
28697
28698 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
28699 {
28700         if (flags & NDR_IN) {
28701         }
28702         if (flags & NDR_OUT) {
28703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28704         }
28705         return NDR_ERR_SUCCESS;
28706 }
28707
28708 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
28709 {
28710         ndr_print_struct(ndr, name, "spoolss_5c");
28711         ndr->depth++;
28712         if (flags & NDR_SET_VALUES) {
28713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28714         }
28715         if (flags & NDR_IN) {
28716                 ndr_print_struct(ndr, "in", "spoolss_5c");
28717                 ndr->depth++;
28718                 ndr->depth--;
28719         }
28720         if (flags & NDR_OUT) {
28721                 ndr_print_struct(ndr, "out", "spoolss_5c");
28722                 ndr->depth++;
28723                 ndr_print_WERROR(ndr, "result", r->out.result);
28724                 ndr->depth--;
28725         }
28726         ndr->depth--;
28727 }
28728
28729 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
28730 {
28731         if (flags & NDR_IN) {
28732         }
28733         if (flags & NDR_OUT) {
28734                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28735         }
28736         return NDR_ERR_SUCCESS;
28737 }
28738
28739 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
28740 {
28741         if (flags & NDR_IN) {
28742         }
28743         if (flags & NDR_OUT) {
28744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28745         }
28746         return NDR_ERR_SUCCESS;
28747 }
28748
28749 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
28750 {
28751         ndr_print_struct(ndr, name, "spoolss_5d");
28752         ndr->depth++;
28753         if (flags & NDR_SET_VALUES) {
28754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28755         }
28756         if (flags & NDR_IN) {
28757                 ndr_print_struct(ndr, "in", "spoolss_5d");
28758                 ndr->depth++;
28759                 ndr->depth--;
28760         }
28761         if (flags & NDR_OUT) {
28762                 ndr_print_struct(ndr, "out", "spoolss_5d");
28763                 ndr->depth++;
28764                 ndr_print_WERROR(ndr, "result", r->out.result);
28765                 ndr->depth--;
28766         }
28767         ndr->depth--;
28768 }
28769
28770 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
28771 {
28772         if (flags & NDR_IN) {
28773         }
28774         if (flags & NDR_OUT) {
28775                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28776         }
28777         return NDR_ERR_SUCCESS;
28778 }
28779
28780 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
28781 {
28782         if (flags & NDR_IN) {
28783         }
28784         if (flags & NDR_OUT) {
28785                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28786         }
28787         return NDR_ERR_SUCCESS;
28788 }
28789
28790 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
28791 {
28792         ndr_print_struct(ndr, name, "spoolss_5e");
28793         ndr->depth++;
28794         if (flags & NDR_SET_VALUES) {
28795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28796         }
28797         if (flags & NDR_IN) {
28798                 ndr_print_struct(ndr, "in", "spoolss_5e");
28799                 ndr->depth++;
28800                 ndr->depth--;
28801         }
28802         if (flags & NDR_OUT) {
28803                 ndr_print_struct(ndr, "out", "spoolss_5e");
28804                 ndr->depth++;
28805                 ndr_print_WERROR(ndr, "result", r->out.result);
28806                 ndr->depth--;
28807         }
28808         ndr->depth--;
28809 }
28810
28811 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
28812 {
28813         if (flags & NDR_IN) {
28814         }
28815         if (flags & NDR_OUT) {
28816                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28817         }
28818         return NDR_ERR_SUCCESS;
28819 }
28820
28821 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
28822 {
28823         if (flags & NDR_IN) {
28824         }
28825         if (flags & NDR_OUT) {
28826                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28827         }
28828         return NDR_ERR_SUCCESS;
28829 }
28830
28831 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
28832 {
28833         ndr_print_struct(ndr, name, "spoolss_5f");
28834         ndr->depth++;
28835         if (flags & NDR_SET_VALUES) {
28836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28837         }
28838         if (flags & NDR_IN) {
28839                 ndr_print_struct(ndr, "in", "spoolss_5f");
28840                 ndr->depth++;
28841                 ndr->depth--;
28842         }
28843         if (flags & NDR_OUT) {
28844                 ndr_print_struct(ndr, "out", "spoolss_5f");
28845                 ndr->depth++;
28846                 ndr_print_WERROR(ndr, "result", r->out.result);
28847                 ndr->depth--;
28848         }
28849         ndr->depth--;
28850 }
28851
28852 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
28853 {
28854         if (flags & NDR_IN) {
28855         }
28856         if (flags & NDR_OUT) {
28857                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28858         }
28859         return NDR_ERR_SUCCESS;
28860 }
28861
28862 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
28863 {
28864         if (flags & NDR_IN) {
28865         }
28866         if (flags & NDR_OUT) {
28867                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28868         }
28869         return NDR_ERR_SUCCESS;
28870 }
28871
28872 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
28873 {
28874         ndr_print_struct(ndr, name, "spoolss_60");
28875         ndr->depth++;
28876         if (flags & NDR_SET_VALUES) {
28877                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28878         }
28879         if (flags & NDR_IN) {
28880                 ndr_print_struct(ndr, "in", "spoolss_60");
28881                 ndr->depth++;
28882                 ndr->depth--;
28883         }
28884         if (flags & NDR_OUT) {
28885                 ndr_print_struct(ndr, "out", "spoolss_60");
28886                 ndr->depth++;
28887                 ndr_print_WERROR(ndr, "result", r->out.result);
28888                 ndr->depth--;
28889         }
28890         ndr->depth--;
28891 }
28892
28893 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
28894 {
28895         if (flags & NDR_IN) {
28896         }
28897         if (flags & NDR_OUT) {
28898                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28899         }
28900         return NDR_ERR_SUCCESS;
28901 }
28902
28903 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
28904 {
28905         if (flags & NDR_IN) {
28906         }
28907         if (flags & NDR_OUT) {
28908                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28909         }
28910         return NDR_ERR_SUCCESS;
28911 }
28912
28913 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
28914 {
28915         ndr_print_struct(ndr, name, "spoolss_61");
28916         ndr->depth++;
28917         if (flags & NDR_SET_VALUES) {
28918                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28919         }
28920         if (flags & NDR_IN) {
28921                 ndr_print_struct(ndr, "in", "spoolss_61");
28922                 ndr->depth++;
28923                 ndr->depth--;
28924         }
28925         if (flags & NDR_OUT) {
28926                 ndr_print_struct(ndr, "out", "spoolss_61");
28927                 ndr->depth++;
28928                 ndr_print_WERROR(ndr, "result", r->out.result);
28929                 ndr->depth--;
28930         }
28931         ndr->depth--;
28932 }
28933
28934 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
28935 {
28936         if (flags & NDR_IN) {
28937         }
28938         if (flags & NDR_OUT) {
28939                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28940         }
28941         return NDR_ERR_SUCCESS;
28942 }
28943
28944 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
28945 {
28946         if (flags & NDR_IN) {
28947         }
28948         if (flags & NDR_OUT) {
28949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28950         }
28951         return NDR_ERR_SUCCESS;
28952 }
28953
28954 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
28955 {
28956         ndr_print_struct(ndr, name, "spoolss_62");
28957         ndr->depth++;
28958         if (flags & NDR_SET_VALUES) {
28959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28960         }
28961         if (flags & NDR_IN) {
28962                 ndr_print_struct(ndr, "in", "spoolss_62");
28963                 ndr->depth++;
28964                 ndr->depth--;
28965         }
28966         if (flags & NDR_OUT) {
28967                 ndr_print_struct(ndr, "out", "spoolss_62");
28968                 ndr->depth++;
28969                 ndr_print_WERROR(ndr, "result", r->out.result);
28970                 ndr->depth--;
28971         }
28972         ndr->depth--;
28973 }
28974
28975 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
28976 {
28977         if (flags & NDR_IN) {
28978         }
28979         if (flags & NDR_OUT) {
28980                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28981         }
28982         return NDR_ERR_SUCCESS;
28983 }
28984
28985 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
28986 {
28987         if (flags & NDR_IN) {
28988         }
28989         if (flags & NDR_OUT) {
28990                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28991         }
28992         return NDR_ERR_SUCCESS;
28993 }
28994
28995 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
28996 {
28997         ndr_print_struct(ndr, name, "spoolss_63");
28998         ndr->depth++;
28999         if (flags & NDR_SET_VALUES) {
29000                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29001         }
29002         if (flags & NDR_IN) {
29003                 ndr_print_struct(ndr, "in", "spoolss_63");
29004                 ndr->depth++;
29005                 ndr->depth--;
29006         }
29007         if (flags & NDR_OUT) {
29008                 ndr_print_struct(ndr, "out", "spoolss_63");
29009                 ndr->depth++;
29010                 ndr_print_WERROR(ndr, "result", r->out.result);
29011                 ndr->depth--;
29012         }
29013         ndr->depth--;
29014 }
29015
29016 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29017 {
29018         if (flags & NDR_IN) {
29019         }
29020         if (flags & NDR_OUT) {
29021                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29022         }
29023         return NDR_ERR_SUCCESS;
29024 }
29025
29026 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29027 {
29028         if (flags & NDR_IN) {
29029         }
29030         if (flags & NDR_OUT) {
29031                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29032         }
29033         return NDR_ERR_SUCCESS;
29034 }
29035
29036 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29037 {
29038         ndr_print_struct(ndr, name, "spoolss_64");
29039         ndr->depth++;
29040         if (flags & NDR_SET_VALUES) {
29041                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29042         }
29043         if (flags & NDR_IN) {
29044                 ndr_print_struct(ndr, "in", "spoolss_64");
29045                 ndr->depth++;
29046                 ndr->depth--;
29047         }
29048         if (flags & NDR_OUT) {
29049                 ndr_print_struct(ndr, "out", "spoolss_64");
29050                 ndr->depth++;
29051                 ndr_print_WERROR(ndr, "result", r->out.result);
29052                 ndr->depth--;
29053         }
29054         ndr->depth--;
29055 }
29056
29057 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29058 {
29059         if (flags & NDR_IN) {
29060         }
29061         if (flags & NDR_OUT) {
29062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29063         }
29064         return NDR_ERR_SUCCESS;
29065 }
29066
29067 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29068 {
29069         if (flags & NDR_IN) {
29070         }
29071         if (flags & NDR_OUT) {
29072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29073         }
29074         return NDR_ERR_SUCCESS;
29075 }
29076
29077 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29078 {
29079         ndr_print_struct(ndr, name, "spoolss_65");
29080         ndr->depth++;
29081         if (flags & NDR_SET_VALUES) {
29082                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29083         }
29084         if (flags & NDR_IN) {
29085                 ndr_print_struct(ndr, "in", "spoolss_65");
29086                 ndr->depth++;
29087                 ndr->depth--;
29088         }
29089         if (flags & NDR_OUT) {
29090                 ndr_print_struct(ndr, "out", "spoolss_65");
29091                 ndr->depth++;
29092                 ndr_print_WERROR(ndr, "result", r->out.result);
29093                 ndr->depth--;
29094         }
29095         ndr->depth--;
29096 }
29097
29098 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29099 {
29100         uint32_t cntr_core_printer_drivers_1;
29101         if (flags & NDR_IN) {
29102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29103                 if (r->in.servername) {
29104                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29107                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29108                 }
29109                 if (r->in.architecture == NULL) {
29110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29111                 }
29112                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29113                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29114                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29115                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29117                 if (r->in.core_driver_dependencies == NULL) {
29118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29119                 }
29120                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29121                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29123         }
29124         if (flags & NDR_OUT) {
29125                 if (r->out.core_printer_drivers == NULL) {
29126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29127                 }
29128                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29129                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29130                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29131                 }
29132                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29133         }
29134         return NDR_ERR_SUCCESS;
29135 }
29136
29137 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29138 {
29139         uint32_t _ptr_servername;
29140         uint32_t cntr_core_printer_drivers_1;
29141         TALLOC_CTX *_mem_save_servername_0;
29142         TALLOC_CTX *_mem_save_core_printer_drivers_1;
29143         if (flags & NDR_IN) {
29144                 ZERO_STRUCT(r->out);
29145
29146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29147                 if (_ptr_servername) {
29148                         NDR_PULL_ALLOC(ndr, r->in.servername);
29149                 } else {
29150                         r->in.servername = NULL;
29151                 }
29152                 if (r->in.servername) {
29153                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29154                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29156                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29157                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29158                                 return 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));
29159                         }
29160                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29161                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29163                 }
29164                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29165                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29166                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29167                         return 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));
29168                 }
29169                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29170                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29172                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29173                 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));
29174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29175                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29176                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29177                 if (r->in.core_driver_dependencies) {
29178                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29179                 }
29180         }
29181         if (flags & NDR_OUT) {
29182                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29184                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29185                 }
29186                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29187                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29188                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29189                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29190                 }
29191                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29192                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29193                 if (r->out.core_printer_drivers) {
29194                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29195                 }
29196         }
29197         return NDR_ERR_SUCCESS;
29198 }
29199
29200 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29201 {
29202         uint32_t cntr_core_printer_drivers_1;
29203         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29204         ndr->depth++;
29205         if (flags & NDR_SET_VALUES) {
29206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29207         }
29208         if (flags & NDR_IN) {
29209                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29210                 ndr->depth++;
29211                 ndr_print_ptr(ndr, "servername", r->in.servername);
29212                 ndr->depth++;
29213                 if (r->in.servername) {
29214                         ndr_print_string(ndr, "servername", r->in.servername);
29215                 }
29216                 ndr->depth--;
29217                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29218                 ndr->depth++;
29219                 ndr_print_string(ndr, "architecture", r->in.architecture);
29220                 ndr->depth--;
29221                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
29222                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29223                 ndr->depth++;
29224                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29225                 ndr->depth--;
29226                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
29227                 ndr->depth--;
29228         }
29229         if (flags & NDR_OUT) {
29230                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
29231                 ndr->depth++;
29232                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
29233                 ndr->depth++;
29234                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
29235                 ndr->depth++;
29236                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
29237                         char *idx_1=NULL;
29238                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
29239                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
29240                                 free(idx_1);
29241                         }
29242                 }
29243                 ndr->depth--;
29244                 ndr->depth--;
29245                 ndr_print_WERROR(ndr, "result", r->out.result);
29246                 ndr->depth--;
29247         }
29248         ndr->depth--;
29249 }
29250
29251 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
29252 {
29253         if (flags & NDR_IN) {
29254         }
29255         if (flags & NDR_OUT) {
29256                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29257         }
29258         return NDR_ERR_SUCCESS;
29259 }
29260
29261 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
29262 {
29263         if (flags & NDR_IN) {
29264         }
29265         if (flags & NDR_OUT) {
29266                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29267         }
29268         return NDR_ERR_SUCCESS;
29269 }
29270
29271 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
29272 {
29273         ndr_print_struct(ndr, name, "spoolss_67");
29274         ndr->depth++;
29275         if (flags & NDR_SET_VALUES) {
29276                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29277         }
29278         if (flags & NDR_IN) {
29279                 ndr_print_struct(ndr, "in", "spoolss_67");
29280                 ndr->depth++;
29281                 ndr->depth--;
29282         }
29283         if (flags & NDR_OUT) {
29284                 ndr_print_struct(ndr, "out", "spoolss_67");
29285                 ndr->depth++;
29286                 ndr_print_WERROR(ndr, "result", r->out.result);
29287                 ndr->depth--;
29288         }
29289         ndr->depth--;
29290 }
29291
29292 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29293 {
29294         if (flags & NDR_IN) {
29295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29296                 if (r->in.servername) {
29297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29301                 }
29302                 if (r->in.architecture == NULL) {
29303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29304                 }
29305                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29306                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29307                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29308                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29310                 if (r->in.language) {
29311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29313                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29315                 }
29316                 if (r->in.package_id == NULL) {
29317                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29318                 }
29319                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29320                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29321                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29322                 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));
29323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29324                 if (r->in.driver_package_cab) {
29325                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29326                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29327                 }
29328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29329         }
29330         if (flags & NDR_OUT) {
29331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29332                 if (r->out.driver_package_cab) {
29333                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29334                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29335                 }
29336                 if (r->out.required == NULL) {
29337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29338                 }
29339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29341         }
29342         return NDR_ERR_SUCCESS;
29343 }
29344
29345 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29346 {
29347         uint32_t _ptr_servername;
29348         uint32_t _ptr_language;
29349         uint32_t _ptr_driver_package_cab;
29350         TALLOC_CTX *_mem_save_servername_0;
29351         TALLOC_CTX *_mem_save_language_0;
29352         TALLOC_CTX *_mem_save_driver_package_cab_0;
29353         TALLOC_CTX *_mem_save_required_0;
29354         if (flags & NDR_IN) {
29355                 ZERO_STRUCT(r->out);
29356
29357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29358                 if (_ptr_servername) {
29359                         NDR_PULL_ALLOC(ndr, r->in.servername);
29360                 } else {
29361                         r->in.servername = NULL;
29362                 }
29363                 if (r->in.servername) {
29364                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29365                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29367                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29368                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29369                                 return 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));
29370                         }
29371                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29374                 }
29375                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29376                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29377                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29378                         return 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));
29379                 }
29380                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29381                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
29383                 if (_ptr_language) {
29384                         NDR_PULL_ALLOC(ndr, r->in.language);
29385                 } else {
29386                         r->in.language = NULL;
29387                 }
29388                 if (r->in.language) {
29389                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
29390                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
29391                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
29392                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
29393                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
29394                                 return 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));
29395                         }
29396                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
29397                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
29398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
29399                 }
29400                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
29401                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
29402                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
29403                         return 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));
29404                 }
29405                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
29406                 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));
29407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29408                 if (_ptr_driver_package_cab) {
29409                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
29410                 } else {
29411                         r->in.driver_package_cab = NULL;
29412                 }
29413                 if (r->in.driver_package_cab) {
29414                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29415                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
29416                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
29417                         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));
29418                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29419                 }
29420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
29421                 NDR_PULL_ALLOC(ndr, r->out.required);
29422                 ZERO_STRUCTP(r->out.required);
29423                 if (r->in.driver_package_cab) {
29424                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
29425                 }
29426         }
29427         if (flags & NDR_OUT) {
29428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29429                 if (_ptr_driver_package_cab) {
29430                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
29431                 } else {
29432                         r->out.driver_package_cab = NULL;
29433                 }
29434                 if (r->out.driver_package_cab) {
29435                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29436                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
29437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
29438                         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));
29439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29440                 }
29441                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29442                         NDR_PULL_ALLOC(ndr, r->out.required);
29443                 }
29444                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
29445                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
29446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
29447                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
29448                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29449                 if (r->out.driver_package_cab) {
29450                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
29451                 }
29452         }
29453         return NDR_ERR_SUCCESS;
29454 }
29455
29456 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29457 {
29458         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
29459         ndr->depth++;
29460         if (flags & NDR_SET_VALUES) {
29461                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29462         }
29463         if (flags & NDR_IN) {
29464                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
29465                 ndr->depth++;
29466                 ndr_print_ptr(ndr, "servername", r->in.servername);
29467                 ndr->depth++;
29468                 if (r->in.servername) {
29469                         ndr_print_string(ndr, "servername", r->in.servername);
29470                 }
29471                 ndr->depth--;
29472                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29473                 ndr->depth++;
29474                 ndr_print_string(ndr, "architecture", r->in.architecture);
29475                 ndr->depth--;
29476                 ndr_print_ptr(ndr, "language", r->in.language);
29477                 ndr->depth++;
29478                 if (r->in.language) {
29479                         ndr_print_string(ndr, "language", r->in.language);
29480                 }
29481                 ndr->depth--;
29482                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
29483                 ndr->depth++;
29484                 ndr_print_string(ndr, "package_id", r->in.package_id);
29485                 ndr->depth--;
29486                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
29487                 ndr->depth++;
29488                 if (r->in.driver_package_cab) {
29489                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
29490                 }
29491                 ndr->depth--;
29492                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
29493                 ndr->depth--;
29494         }
29495         if (flags & NDR_OUT) {
29496                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
29497                 ndr->depth++;
29498                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
29499                 ndr->depth++;
29500                 if (r->out.driver_package_cab) {
29501                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
29502                 }
29503                 ndr->depth--;
29504                 ndr_print_ptr(ndr, "required", r->out.required);
29505                 ndr->depth++;
29506                 ndr_print_uint32(ndr, "required", *r->out.required);
29507                 ndr->depth--;
29508                 ndr_print_WERROR(ndr, "result", r->out.result);
29509                 ndr->depth--;
29510         }
29511         ndr->depth--;
29512 }
29513
29514 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
29515 {
29516         if (flags & NDR_IN) {
29517         }
29518         if (flags & NDR_OUT) {
29519                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29520         }
29521         return NDR_ERR_SUCCESS;
29522 }
29523
29524 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
29525 {
29526         if (flags & NDR_IN) {
29527         }
29528         if (flags & NDR_OUT) {
29529                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29530         }
29531         return NDR_ERR_SUCCESS;
29532 }
29533
29534 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
29535 {
29536         ndr_print_struct(ndr, name, "spoolss_69");
29537         ndr->depth++;
29538         if (flags & NDR_SET_VALUES) {
29539                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29540         }
29541         if (flags & NDR_IN) {
29542                 ndr_print_struct(ndr, "in", "spoolss_69");
29543                 ndr->depth++;
29544                 ndr->depth--;
29545         }
29546         if (flags & NDR_OUT) {
29547                 ndr_print_struct(ndr, "out", "spoolss_69");
29548                 ndr->depth++;
29549                 ndr_print_WERROR(ndr, "result", r->out.result);
29550                 ndr->depth--;
29551         }
29552         ndr->depth--;
29553 }
29554
29555 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
29556 {
29557         if (flags & NDR_IN) {
29558         }
29559         if (flags & NDR_OUT) {
29560                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29561         }
29562         return NDR_ERR_SUCCESS;
29563 }
29564
29565 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
29566 {
29567         if (flags & NDR_IN) {
29568         }
29569         if (flags & NDR_OUT) {
29570                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29571         }
29572         return NDR_ERR_SUCCESS;
29573 }
29574
29575 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
29576 {
29577         ndr_print_struct(ndr, name, "spoolss_6a");
29578         ndr->depth++;
29579         if (flags & NDR_SET_VALUES) {
29580                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29581         }
29582         if (flags & NDR_IN) {
29583                 ndr_print_struct(ndr, "in", "spoolss_6a");
29584                 ndr->depth++;
29585                 ndr->depth--;
29586         }
29587         if (flags & NDR_OUT) {
29588                 ndr_print_struct(ndr, "out", "spoolss_6a");
29589                 ndr->depth++;
29590                 ndr_print_WERROR(ndr, "result", r->out.result);
29591                 ndr->depth--;
29592         }
29593         ndr->depth--;
29594 }
29595
29596 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
29597 {
29598         if (flags & NDR_IN) {
29599         }
29600         if (flags & NDR_OUT) {
29601                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29602         }
29603         return NDR_ERR_SUCCESS;
29604 }
29605
29606 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
29607 {
29608         if (flags & NDR_IN) {
29609         }
29610         if (flags & NDR_OUT) {
29611                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29612         }
29613         return NDR_ERR_SUCCESS;
29614 }
29615
29616 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
29617 {
29618         ndr_print_struct(ndr, name, "spoolss_6b");
29619         ndr->depth++;
29620         if (flags & NDR_SET_VALUES) {
29621                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29622         }
29623         if (flags & NDR_IN) {
29624                 ndr_print_struct(ndr, "in", "spoolss_6b");
29625                 ndr->depth++;
29626                 ndr->depth--;
29627         }
29628         if (flags & NDR_OUT) {
29629                 ndr_print_struct(ndr, "out", "spoolss_6b");
29630                 ndr->depth++;
29631                 ndr_print_WERROR(ndr, "result", r->out.result);
29632                 ndr->depth--;
29633         }
29634         ndr->depth--;
29635 }
29636
29637 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
29638 {
29639         if (flags & NDR_IN) {
29640         }
29641         if (flags & NDR_OUT) {
29642                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29643         }
29644         return NDR_ERR_SUCCESS;
29645 }
29646
29647 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
29648 {
29649         if (flags & NDR_IN) {
29650         }
29651         if (flags & NDR_OUT) {
29652                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29653         }
29654         return NDR_ERR_SUCCESS;
29655 }
29656
29657 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
29658 {
29659         ndr_print_struct(ndr, name, "spoolss_6c");
29660         ndr->depth++;
29661         if (flags & NDR_SET_VALUES) {
29662                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29663         }
29664         if (flags & NDR_IN) {
29665                 ndr_print_struct(ndr, "in", "spoolss_6c");
29666                 ndr->depth++;
29667                 ndr->depth--;
29668         }
29669         if (flags & NDR_OUT) {
29670                 ndr_print_struct(ndr, "out", "spoolss_6c");
29671                 ndr->depth++;
29672                 ndr_print_WERROR(ndr, "result", r->out.result);
29673                 ndr->depth--;
29674         }
29675         ndr->depth--;
29676 }
29677
29678 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
29679 {
29680         if (flags & NDR_IN) {
29681         }
29682         if (flags & NDR_OUT) {
29683                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29684         }
29685         return NDR_ERR_SUCCESS;
29686 }
29687
29688 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
29689 {
29690         if (flags & NDR_IN) {
29691         }
29692         if (flags & NDR_OUT) {
29693                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29694         }
29695         return NDR_ERR_SUCCESS;
29696 }
29697
29698 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
29699 {
29700         ndr_print_struct(ndr, name, "spoolss_6d");
29701         ndr->depth++;
29702         if (flags & NDR_SET_VALUES) {
29703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29704         }
29705         if (flags & NDR_IN) {
29706                 ndr_print_struct(ndr, "in", "spoolss_6d");
29707                 ndr->depth++;
29708                 ndr->depth--;
29709         }
29710         if (flags & NDR_OUT) {
29711                 ndr_print_struct(ndr, "out", "spoolss_6d");
29712                 ndr->depth++;
29713                 ndr_print_WERROR(ndr, "result", r->out.result);
29714                 ndr->depth--;
29715         }
29716         ndr->depth--;
29717 }
29718
29719 static const struct ndr_interface_call spoolss_calls[] = {
29720         {
29721                 "spoolss_EnumPrinters",
29722                 sizeof(struct spoolss_EnumPrinters),
29723                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
29724                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
29725                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
29726                 false,
29727         },
29728         {
29729                 "spoolss_OpenPrinter",
29730                 sizeof(struct spoolss_OpenPrinter),
29731                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
29732                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
29733                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
29734                 false,
29735         },
29736         {
29737                 "spoolss_SetJob",
29738                 sizeof(struct spoolss_SetJob),
29739                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
29740                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
29741                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
29742                 false,
29743         },
29744         {
29745                 "spoolss_GetJob",
29746                 sizeof(struct spoolss_GetJob),
29747                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
29748                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
29749                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
29750                 false,
29751         },
29752         {
29753                 "spoolss_EnumJobs",
29754                 sizeof(struct spoolss_EnumJobs),
29755                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
29756                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
29757                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
29758                 false,
29759         },
29760         {
29761                 "spoolss_AddPrinter",
29762                 sizeof(struct spoolss_AddPrinter),
29763                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
29764                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
29765                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
29766                 false,
29767         },
29768         {
29769                 "spoolss_DeletePrinter",
29770                 sizeof(struct spoolss_DeletePrinter),
29771                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
29772                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
29773                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
29774                 false,
29775         },
29776         {
29777                 "spoolss_SetPrinter",
29778                 sizeof(struct spoolss_SetPrinter),
29779                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
29780                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
29781                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
29782                 false,
29783         },
29784         {
29785                 "spoolss_GetPrinter",
29786                 sizeof(struct spoolss_GetPrinter),
29787                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
29788                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
29789                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
29790                 false,
29791         },
29792         {
29793                 "spoolss_AddPrinterDriver",
29794                 sizeof(struct spoolss_AddPrinterDriver),
29795                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
29796                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
29797                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
29798                 false,
29799         },
29800         {
29801                 "spoolss_EnumPrinterDrivers",
29802                 sizeof(struct spoolss_EnumPrinterDrivers),
29803                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
29804                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
29805                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
29806                 false,
29807         },
29808         {
29809                 "spoolss_GetPrinterDriver",
29810                 sizeof(struct spoolss_GetPrinterDriver),
29811                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
29812                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
29813                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
29814                 false,
29815         },
29816         {
29817                 "spoolss_GetPrinterDriverDirectory",
29818                 sizeof(struct spoolss_GetPrinterDriverDirectory),
29819                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
29820                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
29821                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
29822                 false,
29823         },
29824         {
29825                 "spoolss_DeletePrinterDriver",
29826                 sizeof(struct spoolss_DeletePrinterDriver),
29827                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
29828                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
29829                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
29830                 false,
29831         },
29832         {
29833                 "spoolss_AddPrintProcessor",
29834                 sizeof(struct spoolss_AddPrintProcessor),
29835                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
29836                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
29837                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
29838                 false,
29839         },
29840         {
29841                 "spoolss_EnumPrintProcessors",
29842                 sizeof(struct spoolss_EnumPrintProcessors),
29843                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
29844                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
29845                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
29846                 false,
29847         },
29848         {
29849                 "spoolss_GetPrintProcessorDirectory",
29850                 sizeof(struct spoolss_GetPrintProcessorDirectory),
29851                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
29852                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
29853                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
29854                 false,
29855         },
29856         {
29857                 "spoolss_StartDocPrinter",
29858                 sizeof(struct spoolss_StartDocPrinter),
29859                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
29860                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
29861                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
29862                 false,
29863         },
29864         {
29865                 "spoolss_StartPagePrinter",
29866                 sizeof(struct spoolss_StartPagePrinter),
29867                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
29868                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
29869                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
29870                 false,
29871         },
29872         {
29873                 "spoolss_WritePrinter",
29874                 sizeof(struct spoolss_WritePrinter),
29875                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
29876                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
29877                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
29878                 false,
29879         },
29880         {
29881                 "spoolss_EndPagePrinter",
29882                 sizeof(struct spoolss_EndPagePrinter),
29883                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
29884                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
29885                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
29886                 false,
29887         },
29888         {
29889                 "spoolss_AbortPrinter",
29890                 sizeof(struct spoolss_AbortPrinter),
29891                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
29892                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
29893                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
29894                 false,
29895         },
29896         {
29897                 "spoolss_ReadPrinter",
29898                 sizeof(struct spoolss_ReadPrinter),
29899                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
29900                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
29901                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
29902                 false,
29903         },
29904         {
29905                 "spoolss_EndDocPrinter",
29906                 sizeof(struct spoolss_EndDocPrinter),
29907                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
29908                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
29909                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
29910                 false,
29911         },
29912         {
29913                 "spoolss_AddJob",
29914                 sizeof(struct spoolss_AddJob),
29915                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
29916                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
29917                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
29918                 false,
29919         },
29920         {
29921                 "spoolss_ScheduleJob",
29922                 sizeof(struct spoolss_ScheduleJob),
29923                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
29924                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
29925                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
29926                 false,
29927         },
29928         {
29929                 "spoolss_GetPrinterData",
29930                 sizeof(struct spoolss_GetPrinterData),
29931                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
29932                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
29933                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
29934                 false,
29935         },
29936         {
29937                 "spoolss_SetPrinterData",
29938                 sizeof(struct spoolss_SetPrinterData),
29939                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
29940                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
29941                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
29942                 false,
29943         },
29944         {
29945                 "spoolss_WaitForPrinterChange",
29946                 sizeof(struct spoolss_WaitForPrinterChange),
29947                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
29948                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
29949                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
29950                 false,
29951         },
29952         {
29953                 "spoolss_ClosePrinter",
29954                 sizeof(struct spoolss_ClosePrinter),
29955                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
29956                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
29957                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
29958                 false,
29959         },
29960         {
29961                 "spoolss_AddForm",
29962                 sizeof(struct spoolss_AddForm),
29963                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
29964                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
29965                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
29966                 false,
29967         },
29968         {
29969                 "spoolss_DeleteForm",
29970                 sizeof(struct spoolss_DeleteForm),
29971                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
29972                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
29973                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
29974                 false,
29975         },
29976         {
29977                 "spoolss_GetForm",
29978                 sizeof(struct spoolss_GetForm),
29979                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
29980                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
29981                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
29982                 false,
29983         },
29984         {
29985                 "spoolss_SetForm",
29986                 sizeof(struct spoolss_SetForm),
29987                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
29988                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
29989                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
29990                 false,
29991         },
29992         {
29993                 "spoolss_EnumForms",
29994                 sizeof(struct spoolss_EnumForms),
29995                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
29996                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
29997                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
29998                 false,
29999         },
30000         {
30001                 "spoolss_EnumPorts",
30002                 sizeof(struct spoolss_EnumPorts),
30003                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30004                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30005                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30006                 false,
30007         },
30008         {
30009                 "spoolss_EnumMonitors",
30010                 sizeof(struct spoolss_EnumMonitors),
30011                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30012                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30013                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30014                 false,
30015         },
30016         {
30017                 "spoolss_AddPort",
30018                 sizeof(struct spoolss_AddPort),
30019                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30020                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30021                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30022                 false,
30023         },
30024         {
30025                 "spoolss_ConfigurePort",
30026                 sizeof(struct spoolss_ConfigurePort),
30027                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30028                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30029                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30030                 false,
30031         },
30032         {
30033                 "spoolss_DeletePort",
30034                 sizeof(struct spoolss_DeletePort),
30035                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30036                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30037                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30038                 false,
30039         },
30040         {
30041                 "spoolss_CreatePrinterIC",
30042                 sizeof(struct spoolss_CreatePrinterIC),
30043                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30044                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30045                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30046                 false,
30047         },
30048         {
30049                 "spoolss_PlayGDIScriptOnPrinterIC",
30050                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30051                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30052                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30053                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30054                 false,
30055         },
30056         {
30057                 "spoolss_DeletePrinterIC",
30058                 sizeof(struct spoolss_DeletePrinterIC),
30059                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30060                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30061                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30062                 false,
30063         },
30064         {
30065                 "spoolss_AddPrinterConnection",
30066                 sizeof(struct spoolss_AddPrinterConnection),
30067                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30068                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30069                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30070                 false,
30071         },
30072         {
30073                 "spoolss_DeletePrinterConnection",
30074                 sizeof(struct spoolss_DeletePrinterConnection),
30075                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30076                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30077                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30078                 false,
30079         },
30080         {
30081                 "spoolss_PrinterMessageBox",
30082                 sizeof(struct spoolss_PrinterMessageBox),
30083                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30084                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30085                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30086                 false,
30087         },
30088         {
30089                 "spoolss_AddMonitor",
30090                 sizeof(struct spoolss_AddMonitor),
30091                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30092                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30093                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30094                 false,
30095         },
30096         {
30097                 "spoolss_DeleteMonitor",
30098                 sizeof(struct spoolss_DeleteMonitor),
30099                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30100                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30101                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30102                 false,
30103         },
30104         {
30105                 "spoolss_DeletePrintProcessor",
30106                 sizeof(struct spoolss_DeletePrintProcessor),
30107                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30108                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30109                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30110                 false,
30111         },
30112         {
30113                 "spoolss_AddPrintProvidor",
30114                 sizeof(struct spoolss_AddPrintProvidor),
30115                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30116                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30117                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30118                 false,
30119         },
30120         {
30121                 "spoolss_DeletePrintProvidor",
30122                 sizeof(struct spoolss_DeletePrintProvidor),
30123                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30124                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30125                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30126                 false,
30127         },
30128         {
30129                 "spoolss_EnumPrintProcDataTypes",
30130                 sizeof(struct spoolss_EnumPrintProcDataTypes),
30131                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30132                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30133                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30134                 false,
30135         },
30136         {
30137                 "spoolss_ResetPrinter",
30138                 sizeof(struct spoolss_ResetPrinter),
30139                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30140                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30141                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30142                 false,
30143         },
30144         {
30145                 "spoolss_GetPrinterDriver2",
30146                 sizeof(struct spoolss_GetPrinterDriver2),
30147                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30148                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30149                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30150                 false,
30151         },
30152         {
30153                 "spoolss_FindFirstPrinterChangeNotification",
30154                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30155                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30156                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30157                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30158                 false,
30159         },
30160         {
30161                 "spoolss_FindNextPrinterChangeNotification",
30162                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
30163                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30164                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30165                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30166                 false,
30167         },
30168         {
30169                 "spoolss_FindClosePrinterNotify",
30170                 sizeof(struct spoolss_FindClosePrinterNotify),
30171                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30172                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30173                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30174                 false,
30175         },
30176         {
30177                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30178                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30179                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30180                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30181                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30182                 false,
30183         },
30184         {
30185                 "spoolss_ReplyOpenPrinter",
30186                 sizeof(struct spoolss_ReplyOpenPrinter),
30187                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30188                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30189                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30190                 false,
30191         },
30192         {
30193                 "spoolss_RouterReplyPrinter",
30194                 sizeof(struct spoolss_RouterReplyPrinter),
30195                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30196                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30197                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30198                 false,
30199         },
30200         {
30201                 "spoolss_ReplyClosePrinter",
30202                 sizeof(struct spoolss_ReplyClosePrinter),
30203                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30204                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30205                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30206                 false,
30207         },
30208         {
30209                 "spoolss_AddPortEx",
30210                 sizeof(struct spoolss_AddPortEx),
30211                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30212                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30213                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30214                 false,
30215         },
30216         {
30217                 "spoolss_RouterFindFirstPrinterChangeNotification",
30218                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30219                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30220                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30221                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
30222                 false,
30223         },
30224         {
30225                 "spoolss_SpoolerInit",
30226                 sizeof(struct spoolss_SpoolerInit),
30227                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
30228                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
30229                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
30230                 false,
30231         },
30232         {
30233                 "spoolss_ResetPrinterEx",
30234                 sizeof(struct spoolss_ResetPrinterEx),
30235                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
30236                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
30237                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
30238                 false,
30239         },
30240         {
30241                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
30242                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
30243                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30244                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30245                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30246                 false,
30247         },
30248         {
30249                 "spoolss_RouterReplyPrinterEx",
30250                 sizeof(struct spoolss_RouterReplyPrinterEx),
30251                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
30252                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
30253                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
30254                 false,
30255         },
30256         {
30257                 "spoolss_RouterRefreshPrinterChangeNotify",
30258                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
30259                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
30260                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
30261                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
30262                 false,
30263         },
30264         {
30265                 "spoolss_44",
30266                 sizeof(struct spoolss_44),
30267                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
30268                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
30269                 (ndr_print_function_t) ndr_print_spoolss_44,
30270                 false,
30271         },
30272         {
30273                 "spoolss_OpenPrinterEx",
30274                 sizeof(struct spoolss_OpenPrinterEx),
30275                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
30276                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
30277                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
30278                 false,
30279         },
30280         {
30281                 "spoolss_AddPrinterEx",
30282                 sizeof(struct spoolss_AddPrinterEx),
30283                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
30284                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
30285                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
30286                 false,
30287         },
30288         {
30289                 "spoolss_47",
30290                 sizeof(struct spoolss_47),
30291                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
30292                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30293                 (ndr_print_function_t) ndr_print_spoolss_47,
30294                 false,
30295         },
30296         {
30297                 "spoolss_EnumPrinterData",
30298                 sizeof(struct spoolss_EnumPrinterData),
30299                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30300                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30301                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30302                 false,
30303         },
30304         {
30305                 "spoolss_DeletePrinterData",
30306                 sizeof(struct spoolss_DeletePrinterData),
30307                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30308                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30309                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30310                 false,
30311         },
30312         {
30313                 "spoolss_4a",
30314                 sizeof(struct spoolss_4a),
30315                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30316                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30317                 (ndr_print_function_t) ndr_print_spoolss_4a,
30318                 false,
30319         },
30320         {
30321                 "spoolss_4b",
30322                 sizeof(struct spoolss_4b),
30323                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30324                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30325                 (ndr_print_function_t) ndr_print_spoolss_4b,
30326                 false,
30327         },
30328         {
30329                 "spoolss_4c",
30330                 sizeof(struct spoolss_4c),
30331                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30332                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30333                 (ndr_print_function_t) ndr_print_spoolss_4c,
30334                 false,
30335         },
30336         {
30337                 "spoolss_SetPrinterDataEx",
30338                 sizeof(struct spoolss_SetPrinterDataEx),
30339                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30340                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30341                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30342                 false,
30343         },
30344         {
30345                 "spoolss_GetPrinterDataEx",
30346                 sizeof(struct spoolss_GetPrinterDataEx),
30347                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30348                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30349                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30350                 false,
30351         },
30352         {
30353                 "spoolss_EnumPrinterDataEx",
30354                 sizeof(struct spoolss_EnumPrinterDataEx),
30355                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30356                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30357                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30358                 false,
30359         },
30360         {
30361                 "spoolss_EnumPrinterKey",
30362                 sizeof(struct spoolss_EnumPrinterKey),
30363                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
30364                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
30365                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
30366                 false,
30367         },
30368         {
30369                 "spoolss_DeletePrinterDataEx",
30370                 sizeof(struct spoolss_DeletePrinterDataEx),
30371                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
30372                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
30373                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
30374                 false,
30375         },
30376         {
30377                 "spoolss_DeletePrinterKey",
30378                 sizeof(struct spoolss_DeletePrinterKey),
30379                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
30380                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
30381                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
30382                 false,
30383         },
30384         {
30385                 "spoolss_53",
30386                 sizeof(struct spoolss_53),
30387                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
30388                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
30389                 (ndr_print_function_t) ndr_print_spoolss_53,
30390                 false,
30391         },
30392         {
30393                 "spoolss_DeletePrinterDriverEx",
30394                 sizeof(struct spoolss_DeletePrinterDriverEx),
30395                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
30396                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
30397                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
30398                 false,
30399         },
30400         {
30401                 "spoolss_55",
30402                 sizeof(struct spoolss_55),
30403                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
30404                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
30405                 (ndr_print_function_t) ndr_print_spoolss_55,
30406                 false,
30407         },
30408         {
30409                 "spoolss_56",
30410                 sizeof(struct spoolss_56),
30411                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
30412                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
30413                 (ndr_print_function_t) ndr_print_spoolss_56,
30414                 false,
30415         },
30416         {
30417                 "spoolss_57",
30418                 sizeof(struct spoolss_57),
30419                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
30420                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
30421                 (ndr_print_function_t) ndr_print_spoolss_57,
30422                 false,
30423         },
30424         {
30425                 "spoolss_XcvData",
30426                 sizeof(struct spoolss_XcvData),
30427                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
30428                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
30429                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
30430                 false,
30431         },
30432         {
30433                 "spoolss_AddPrinterDriverEx",
30434                 sizeof(struct spoolss_AddPrinterDriverEx),
30435                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
30436                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
30437                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
30438                 false,
30439         },
30440         {
30441                 "spoolss_5a",
30442                 sizeof(struct spoolss_5a),
30443                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
30444                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
30445                 (ndr_print_function_t) ndr_print_spoolss_5a,
30446                 false,
30447         },
30448         {
30449                 "spoolss_5b",
30450                 sizeof(struct spoolss_5b),
30451                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
30452                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
30453                 (ndr_print_function_t) ndr_print_spoolss_5b,
30454                 false,
30455         },
30456         {
30457                 "spoolss_5c",
30458                 sizeof(struct spoolss_5c),
30459                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
30460                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
30461                 (ndr_print_function_t) ndr_print_spoolss_5c,
30462                 false,
30463         },
30464         {
30465                 "spoolss_5d",
30466                 sizeof(struct spoolss_5d),
30467                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
30468                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
30469                 (ndr_print_function_t) ndr_print_spoolss_5d,
30470                 false,
30471         },
30472         {
30473                 "spoolss_5e",
30474                 sizeof(struct spoolss_5e),
30475                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
30476                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
30477                 (ndr_print_function_t) ndr_print_spoolss_5e,
30478                 false,
30479         },
30480         {
30481                 "spoolss_5f",
30482                 sizeof(struct spoolss_5f),
30483                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
30484                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
30485                 (ndr_print_function_t) ndr_print_spoolss_5f,
30486                 false,
30487         },
30488         {
30489                 "spoolss_60",
30490                 sizeof(struct spoolss_60),
30491                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
30492                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
30493                 (ndr_print_function_t) ndr_print_spoolss_60,
30494                 false,
30495         },
30496         {
30497                 "spoolss_61",
30498                 sizeof(struct spoolss_61),
30499                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
30500                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
30501                 (ndr_print_function_t) ndr_print_spoolss_61,
30502                 false,
30503         },
30504         {
30505                 "spoolss_62",
30506                 sizeof(struct spoolss_62),
30507                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
30508                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
30509                 (ndr_print_function_t) ndr_print_spoolss_62,
30510                 false,
30511         },
30512         {
30513                 "spoolss_63",
30514                 sizeof(struct spoolss_63),
30515                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
30516                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
30517                 (ndr_print_function_t) ndr_print_spoolss_63,
30518                 false,
30519         },
30520         {
30521                 "spoolss_64",
30522                 sizeof(struct spoolss_64),
30523                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
30524                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
30525                 (ndr_print_function_t) ndr_print_spoolss_64,
30526                 false,
30527         },
30528         {
30529                 "spoolss_65",
30530                 sizeof(struct spoolss_65),
30531                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
30532                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
30533                 (ndr_print_function_t) ndr_print_spoolss_65,
30534                 false,
30535         },
30536         {
30537                 "spoolss_GetCorePrinterDrivers",
30538                 sizeof(struct spoolss_GetCorePrinterDrivers),
30539                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
30540                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
30541                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
30542                 false,
30543         },
30544         {
30545                 "spoolss_67",
30546                 sizeof(struct spoolss_67),
30547                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
30548                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
30549                 (ndr_print_function_t) ndr_print_spoolss_67,
30550                 false,
30551         },
30552         {
30553                 "spoolss_GetPrinterDriverPackagePath",
30554                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
30555                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
30556                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
30557                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
30558                 false,
30559         },
30560         {
30561                 "spoolss_69",
30562                 sizeof(struct spoolss_69),
30563                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
30564                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
30565                 (ndr_print_function_t) ndr_print_spoolss_69,
30566                 false,
30567         },
30568         {
30569                 "spoolss_6a",
30570                 sizeof(struct spoolss_6a),
30571                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
30572                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
30573                 (ndr_print_function_t) ndr_print_spoolss_6a,
30574                 false,
30575         },
30576         {
30577                 "spoolss_6b",
30578                 sizeof(struct spoolss_6b),
30579                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
30580                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
30581                 (ndr_print_function_t) ndr_print_spoolss_6b,
30582                 false,
30583         },
30584         {
30585                 "spoolss_6c",
30586                 sizeof(struct spoolss_6c),
30587                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
30588                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
30589                 (ndr_print_function_t) ndr_print_spoolss_6c,
30590                 false,
30591         },
30592         {
30593                 "spoolss_6d",
30594                 sizeof(struct spoolss_6d),
30595                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
30596                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
30597                 (ndr_print_function_t) ndr_print_spoolss_6d,
30598                 false,
30599         },
30600         { NULL, 0, NULL, NULL, NULL, false }
30601 };
30602
30603 static const char * const spoolss_endpoint_strings[] = {
30604         "ncacn_np:[\\pipe\\spoolss]",
30605 };
30606
30607 static const struct ndr_interface_string_array spoolss_endpoints = {
30608         .count  = 1,
30609         .names  = spoolss_endpoint_strings
30610 };
30611
30612 static const char * const spoolss_authservice_strings[] = {
30613         "host",
30614 };
30615
30616 static const struct ndr_interface_string_array spoolss_authservices = {
30617         .count  = 1,
30618         .names  = spoolss_authservice_strings
30619 };
30620
30621
30622 const struct ndr_interface_table ndr_table_spoolss = {
30623         .name           = "spoolss",
30624         .syntax_id      = {
30625                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
30626                 NDR_SPOOLSS_VERSION
30627         },
30628         .helpstring     = NDR_SPOOLSS_HELPSTRING,
30629         .num_calls      = 110,
30630         .calls          = spoolss_calls,
30631         .endpoints      = &spoolss_endpoints,
30632         .authservices   = &spoolss_authservices
30633 };
30634