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_start(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
 364                         }
 365                         ndr->flags = _flags_save_string;
 366                 }
 367                 {
 368                         uint32_t _flags_save_string = ndr->flags;
 369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 370                         if (r->servername) {
 371                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
 372                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 373                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
 374                         }
 375                         ndr->flags = _flags_save_string;
 376                 }
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 382 {
 383         uint32_t _ptr_printername;
 384         TALLOC_CTX *_mem_save_printername_0;
 385         uint32_t _ptr_servername;
 386         TALLOC_CTX *_mem_save_servername_0;
 387         if (ndr_flags & NDR_SCALARS) {
 388                 NDR_CHECK(ndr_pull_align(ndr, 5));
 389                 {
 390                         uint32_t _flags_save_string = ndr->flags;
 391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 393                         if (_ptr_printername) {
 394                                 NDR_PULL_ALLOC(ndr, r->printername);
 395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 396                         } else {
 397                                 r->printername = NULL;
 398                         }
 399                         ndr->flags = _flags_save_string;
 400                 }
 401                 {
 402                         uint32_t _flags_save_string = ndr->flags;
 403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 405                         if (_ptr_servername) {
 406                                 NDR_PULL_ALLOC(ndr, r->servername);
 407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 408                         } else {
 409                                 r->servername = NULL;
 410                         }
 411                         ndr->flags = _flags_save_string;
 412                 }
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 416                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 426                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 431                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 432                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 435                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 436                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 440                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 441         }
 442         if (ndr_flags & NDR_BUFFERS) {
 443                 {
 444                         uint32_t _flags_save_string = ndr->flags;
 445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 446                         if (r->printername) {
 447                                 uint32_t _relative_save_offset;
 448                                 _relative_save_offset = ndr->offset;
 449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 450                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 451                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 454                                 if (ndr->offset > ndr->relative_highest_offset) {
 455                                         ndr->relative_highest_offset = ndr->offset;
 456                                 }
 457                                 ndr->offset = _relative_save_offset;
 458                         }
 459                         ndr->flags = _flags_save_string;
 460                 }
 461                 {
 462                         uint32_t _flags_save_string = ndr->flags;
 463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 464                         if (r->servername) {
 465                                 uint32_t _relative_save_offset;
 466                                 _relative_save_offset = ndr->offset;
 467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 468                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 469                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 472                                 if (ndr->offset > ndr->relative_highest_offset) {
 473                                         ndr->relative_highest_offset = ndr->offset;
 474                                 }
 475                                 ndr->offset = _relative_save_offset;
 476                         }
 477                         ndr->flags = _flags_save_string;
 478                 }
 479         }
 480         return NDR_ERR_SUCCESS;
 481 }
 482
 483 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 484 {
 485         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 486         ndr->depth++;
 487         ndr_print_ptr(ndr, "printername", r->printername);
 488         ndr->depth++;
 489         if (r->printername) {
 490                 ndr_print_string(ndr, "printername", r->printername);
 491         }
 492         ndr->depth--;
 493         ndr_print_ptr(ndr, "servername", r->servername);
 494         ndr->depth++;
 495         if (r->servername) {
 496                 ndr_print_string(ndr, "servername", r->servername);
 497         }
 498         ndr->depth--;
 499         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 500         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 501         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 502         ndr_print_spoolss_Time(ndr, "time", &r->time);
 503         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 504         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 505         ndr_print_uint32(ndr, "version", r->version);
 506         ndr_print_uint32(ndr, "free_build", r->free_build);
 507         ndr_print_uint32(ndr, "spooling", r->spooling);
 508         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 509         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 510         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 511         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 512         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 513         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 514         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 515         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 516         ndr_print_uint32(ndr, "change_id", r->change_id);
 517         ndr_print_WERROR(ndr, "last_error", r->last_error);
 518         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 519         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 520         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 521         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 522         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 523         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 524         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 525         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 526         ndr->depth--;
 527 }
 528
 529 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 530 {
 531         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 532 }
 533
 534 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 535 {
 536         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 537         return NDR_ERR_SUCCESS;
 538 }
 539
 540 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 541 {
 542         uint32_t v;
 543         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 544         *r = v;
 545         return NDR_ERR_SUCCESS;
 546 }
 547
 548 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 549 {
 550         ndr_print_uint32(ndr, name, r);
 551         ndr->depth++;
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 578         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 580         ndr->depth--;
 581 }
 582
 583 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 584 {
 585         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 586         return NDR_ERR_SUCCESS;
 587 }
 588
 589 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 590 {
 591         uint16_t v;
 592         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 593         *r = v;
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 598 {
 599         const char *val = NULL;
 600
 601         switch (r) {
 602                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 603                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 604                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 605         }
 606         ndr_print_enum(ndr, name, "ENUM", val, r);
 607 }
 608
 609 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 610 {
 611         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 612         return NDR_ERR_SUCCESS;
 613 }
 614
 615 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 616 {
 617         uint16_t v;
 618         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 619         *r = v;
 620         return NDR_ERR_SUCCESS;
 621 }
 622
 623 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 624 {
 625         const char *val = NULL;
 626
 627         switch (r) {
 628                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 629                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 630         }
 631         ndr_print_enum(ndr, name, "ENUM", val, r);
 632 }
 633
 634 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 635 {
 636         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 637         return NDR_ERR_SUCCESS;
 638 }
 639
 640 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 641 {
 642         uint16_t v;
 643         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 644         *r = v;
 645         return NDR_ERR_SUCCESS;
 646 }
 647
 648 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 649 {
 650         const char *val = NULL;
 651
 652         switch (r) {
 653                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 654                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 655                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 656                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 657                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 658                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 659                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 660                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 661                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 662                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 663                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 664                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 665                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 666                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 667                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 668                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 669                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 670                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 671                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 672                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 673                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 674                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 675                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 676                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 677                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 678                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 679                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 680                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 681                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 682                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 683                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 684                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 685                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 686                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 687                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 688                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 689                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 690                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 691                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 692                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 693                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 694                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 695                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 696                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 697                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 698                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 699                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 700                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 701                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 702                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 703                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 704                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 705                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 706                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 707                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 708                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 709                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 710                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 711                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 712                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 713                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 714                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 715                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 716                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 717                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 718                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 719                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 720                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 721                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 722                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 723                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 724                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 725                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 726                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 727                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 728                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 729                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 730                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 731                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 732                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 733                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 734                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 735                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 736                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 737                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 738                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 739                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 740                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 741                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 742                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 743                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 744         }
 745         ndr_print_enum(ndr, name, "ENUM", val, r);
 746 }
 747
 748 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 749 {
 750         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 751         return NDR_ERR_SUCCESS;
 752 }
 753
 754 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 755 {
 756         uint16_t v;
 757         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 758         *r = v;
 759         return NDR_ERR_SUCCESS;
 760 }
 761
 762 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 763 {
 764         const char *val = NULL;
 765
 766         switch (r) {
 767                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 768                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 769                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 770                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 771                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 772                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 773                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 774                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 775                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 776                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 777                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 778                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 779                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 780         }
 781         ndr_print_enum(ndr, name, "ENUM", val, r);
 782 }
 783
 784 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 785 {
 786         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 787         return NDR_ERR_SUCCESS;
 788 }
 789
 790 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 791 {
 792         uint16_t v;
 793         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 794         *r = v;
 795         return NDR_ERR_SUCCESS;
 796 }
 797
 798 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 799 {
 800         const char *val = NULL;
 801
 802         switch (r) {
 803                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 804                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 805                 case DMRES_LOW: val = "DMRES_LOW"; break;
 806                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 807         }
 808         ndr_print_enum(ndr, name, "ENUM", val, r);
 809 }
 810
 811 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 812 {
 813         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 818 {
 819         uint16_t v;
 820         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 821         *r = v;
 822         return NDR_ERR_SUCCESS;
 823 }
 824
 825 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 826 {
 827         const char *val = NULL;
 828
 829         switch (r) {
 830                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 831                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 832         }
 833         ndr_print_enum(ndr, name, "ENUM", val, r);
 834 }
 835
 836 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 837 {
 838         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 839         return NDR_ERR_SUCCESS;
 840 }
 841
 842 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 843 {
 844         uint16_t v;
 845         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 846         *r = v;
 847         return NDR_ERR_SUCCESS;
 848 }
 849
 850 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 851 {
 852         const char *val = NULL;
 853
 854         switch (r) {
 855                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 856                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 857                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 858         }
 859         ndr_print_enum(ndr, name, "ENUM", val, r);
 860 }
 861
 862 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 863 {
 864         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 865         return NDR_ERR_SUCCESS;
 866 }
 867
 868 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 869 {
 870         uint16_t v;
 871         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 872         *r = v;
 873         return NDR_ERR_SUCCESS;
 874 }
 875
 876 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 877 {
 878         const char *val = NULL;
 879
 880         switch (r) {
 881                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 882                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 883                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 884                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 885         }
 886         ndr_print_enum(ndr, name, "ENUM", val, r);
 887 }
 888
 889 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 890 {
 891         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 892         return NDR_ERR_SUCCESS;
 893 }
 894
 895 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 896 {
 897         uint16_t v;
 898         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 899         *r = v;
 900         return NDR_ERR_SUCCESS;
 901 }
 902
 903 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 904 {
 905         const char *val = NULL;
 906
 907         switch (r) {
 908                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 909                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 910         }
 911         ndr_print_enum(ndr, name, "ENUM", val, r);
 912 }
 913
 914 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 915 {
 916         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 921 {
 922         uint32_t v;
 923         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 924         *r = v;
 925         return NDR_ERR_SUCCESS;
 926 }
 927
 928 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 929 {
 930         const char *val = NULL;
 931
 932         switch (r) {
 933                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 934                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 935         }
 936         ndr_print_enum(ndr, name, "ENUM", val, r);
 937 }
 938
 939 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 940 {
 941         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 946 {
 947         uint32_t v;
 948         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 949         *r = v;
 950         return NDR_ERR_SUCCESS;
 951 }
 952
 953 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 954 {
 955         const char *val = NULL;
 956
 957         switch (r) {
 958                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 959                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 960                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 961                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 962         }
 963         ndr_print_enum(ndr, name, "ENUM", val, r);
 964 }
 965
 966 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 967 {
 968         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 969         return NDR_ERR_SUCCESS;
 970 }
 971
 972 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 973 {
 974         uint32_t v;
 975         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 976         *r = v;
 977         return NDR_ERR_SUCCESS;
 978 }
 979
 980 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 981 {
 982         const char *val = NULL;
 983
 984         switch (r) {
 985                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 986                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 987                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 988                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 989         }
 990         ndr_print_enum(ndr, name, "ENUM", val, r);
 991 }
 992
 993 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 994 {
 995         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 996         return NDR_ERR_SUCCESS;
 997 }
 998
 999 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
1000 {
1001         uint32_t v;
1002         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1003         *r = v;
1004         return NDR_ERR_SUCCESS;
1005 }
1006
1007 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1008 {
1009         const char *val = NULL;
1010
1011         switch (r) {
1012                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1013                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1014                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1015         }
1016         ndr_print_enum(ndr, name, "ENUM", val, r);
1017 }
1018
1019 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1020 {
1021         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1022         return NDR_ERR_SUCCESS;
1023 }
1024
1025 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1026 {
1027         uint32_t v;
1028         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1029         *r = v;
1030         return NDR_ERR_SUCCESS;
1031 }
1032
1033 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1034 {
1035         const char *val = NULL;
1036
1037         switch (r) {
1038                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1039                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1040                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1041                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1042                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1043                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1044                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1045                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1046                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1047                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1048         }
1049         ndr_print_enum(ndr, name, "ENUM", val, r);
1050 }
1051
1052 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1053 {
1054         if (ndr_flags & NDR_SCALARS) {
1055                 NDR_CHECK(ndr_push_align(ndr, 4));
1056                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1057                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1059                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1060                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1062                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1063                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1066                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1067                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1070                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1072                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1073                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1074                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1075                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1076                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1080                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1082                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1083                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1084                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1085                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1090                 {
1091                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1093                         {
1094                                 struct ndr_push *_ndr_driverextra_data;
1095                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1096                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1097                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1098                         }
1099                         ndr->flags = _flags_save_DATA_BLOB;
1100                 }
1101                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1102         }
1103         if (ndr_flags & NDR_BUFFERS) {
1104         }
1105         return NDR_ERR_SUCCESS;
1106 }
1107
1108 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1109 {
1110         if (ndr_flags & NDR_SCALARS) {
1111                 NDR_CHECK(ndr_pull_align(ndr, 4));
1112                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1113                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1115                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1116                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1118                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1119                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1122                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1123                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1126                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1127                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1128                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1129                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1130                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1131                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1132                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1136                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1138                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1139                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1140                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1141                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1146                 {
1147                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1149                         {
1150                                 struct ndr_pull *_ndr_driverextra_data;
1151                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1152                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1153                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1154                         }
1155                         ndr->flags = _flags_save_DATA_BLOB;
1156                 }
1157                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1158         }
1159         if (ndr_flags & NDR_BUFFERS) {
1160         }
1161         return NDR_ERR_SUCCESS;
1162 }
1163
1164 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1165 {
1166         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1167         ndr->depth++;
1168         ndr_print_string(ndr, "devicename", r->devicename);
1169         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1170         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1171         ndr_print_uint16(ndr, "size", r->size);
1172         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1173         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1174         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1175         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1176         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1177         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1178         ndr_print_uint16(ndr, "scale", r->scale);
1179         ndr_print_uint16(ndr, "copies", r->copies);
1180         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1181         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1182         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1183         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1184         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1185         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1186         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1187         ndr_print_string(ndr, "formname", r->formname);
1188         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1189         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1190         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1191         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1192         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1193         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1194         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1195         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1196         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1197         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1198         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1199         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1200         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1201         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1202         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1203         ndr->depth--;
1204 }
1205
1206 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1207 {
1208         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1209 }
1210
1211 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1212 {
1213         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1214         return NDR_ERR_SUCCESS;
1215 }
1216
1217 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1218 {
1219         uint32_t v;
1220         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1221         *r = v;
1222         return NDR_ERR_SUCCESS;
1223 }
1224
1225 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1226 {
1227         ndr_print_uint32(ndr, name, r);
1228         ndr->depth++;
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1248         ndr->depth--;
1249 }
1250
1251 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1252 {
1253         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1254         return NDR_ERR_SUCCESS;
1255 }
1256
1257 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1258 {
1259         uint32_t v;
1260         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1261         *r = v;
1262         return NDR_ERR_SUCCESS;
1263 }
1264
1265 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1266 {
1267         ndr_print_uint32(ndr, name, r);
1268         ndr->depth++;
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1283         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1284         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1285         ndr->depth--;
1286 }
1287
1288 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1289 {
1290         if (ndr_flags & NDR_SCALARS) {
1291                 NDR_CHECK(ndr_push_align(ndr, 5));
1292                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1297                         ndr->flags = _flags_save_string;
1298                 }
1299                 {
1300                         uint32_t _flags_save_string = ndr->flags;
1301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 {
1306                         uint32_t _flags_save_string = ndr->flags;
1307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1308                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1309                         ndr->flags = _flags_save_string;
1310                 }
1311                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1312         }
1313         if (ndr_flags & NDR_BUFFERS) {
1314                 {
1315                         uint32_t _flags_save_string = ndr->flags;
1316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317                         if (r->description) {
1318                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1319                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1320                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         if (r->name) {
1328                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name));
1329                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1330                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name));
1331                         }
1332                         ndr->flags = _flags_save_string;
1333                 }
1334                 {
1335                         uint32_t _flags_save_string = ndr->flags;
1336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1337                         if (r->comment) {
1338                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1340                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1341                         }
1342                         ndr->flags = _flags_save_string;
1343                 }
1344         }
1345         return NDR_ERR_SUCCESS;
1346 }
1347
1348 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1349 {
1350         uint32_t _ptr_description;
1351         TALLOC_CTX *_mem_save_description_0;
1352         uint32_t _ptr_name;
1353         TALLOC_CTX *_mem_save_name_0;
1354         uint32_t _ptr_comment;
1355         TALLOC_CTX *_mem_save_comment_0;
1356         if (ndr_flags & NDR_SCALARS) {
1357                 NDR_CHECK(ndr_pull_align(ndr, 5));
1358                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1359                 {
1360                         uint32_t _flags_save_string = ndr->flags;
1361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1362                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1363                         if (_ptr_description) {
1364                                 NDR_PULL_ALLOC(ndr, r->description);
1365                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1366                         } else {
1367                                 r->description = NULL;
1368                         }
1369                         ndr->flags = _flags_save_string;
1370                 }
1371                 {
1372                         uint32_t _flags_save_string = ndr->flags;
1373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1374                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1375                         if (_ptr_name) {
1376                                 NDR_PULL_ALLOC(ndr, r->name);
1377                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1378                         } else {
1379                                 r->name = NULL;
1380                         }
1381                         ndr->flags = _flags_save_string;
1382                 }
1383                 {
1384                         uint32_t _flags_save_string = ndr->flags;
1385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1386                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1387                         if (_ptr_comment) {
1388                                 NDR_PULL_ALLOC(ndr, r->comment);
1389                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1390                         } else {
1391                                 r->comment = NULL;
1392                         }
1393                         ndr->flags = _flags_save_string;
1394                 }
1395                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1396         }
1397         if (ndr_flags & NDR_BUFFERS) {
1398                 {
1399                         uint32_t _flags_save_string = ndr->flags;
1400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1401                         if (r->description) {
1402                                 uint32_t _relative_save_offset;
1403                                 _relative_save_offset = ndr->offset;
1404                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1405                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1406                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1407                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1408                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1409                                 if (ndr->offset > ndr->relative_highest_offset) {
1410                                         ndr->relative_highest_offset = ndr->offset;
1411                                 }
1412                                 ndr->offset = _relative_save_offset;
1413                         }
1414                         ndr->flags = _flags_save_string;
1415                 }
1416                 {
1417                         uint32_t _flags_save_string = ndr->flags;
1418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1419                         if (r->name) {
1420                                 uint32_t _relative_save_offset;
1421                                 _relative_save_offset = ndr->offset;
1422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1423                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1424                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1427                                 if (ndr->offset > ndr->relative_highest_offset) {
1428                                         ndr->relative_highest_offset = ndr->offset;
1429                                 }
1430                                 ndr->offset = _relative_save_offset;
1431                         }
1432                         ndr->flags = _flags_save_string;
1433                 }
1434                 {
1435                         uint32_t _flags_save_string = ndr->flags;
1436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1437                         if (r->comment) {
1438                                 uint32_t _relative_save_offset;
1439                                 _relative_save_offset = ndr->offset;
1440                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1441                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1442                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1443                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1444                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1445                                 if (ndr->offset > ndr->relative_highest_offset) {
1446                                         ndr->relative_highest_offset = ndr->offset;
1447                                 }
1448                                 ndr->offset = _relative_save_offset;
1449                         }
1450                         ndr->flags = _flags_save_string;
1451                 }
1452         }
1453         return NDR_ERR_SUCCESS;
1454 }
1455
1456 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1457 {
1458         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1459         ndr->depth++;
1460         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1461         ndr_print_ptr(ndr, "description", r->description);
1462         ndr->depth++;
1463         if (r->description) {
1464                 ndr_print_string(ndr, "description", r->description);
1465         }
1466         ndr->depth--;
1467         ndr_print_ptr(ndr, "name", r->name);
1468         ndr->depth++;
1469         if (r->name) {
1470                 ndr_print_string(ndr, "name", r->name);
1471         }
1472         ndr->depth--;
1473         ndr_print_ptr(ndr, "comment", r->comment);
1474         ndr->depth++;
1475         if (r->comment) {
1476                 ndr_print_string(ndr, "comment", r->comment);
1477         }
1478         ndr->depth--;
1479         ndr->depth--;
1480 }
1481
1482 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1483 {
1484         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1485 }
1486
1487 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1488 {
1489         if (ndr_flags & NDR_SCALARS) {
1490                 NDR_CHECK(ndr_push_align(ndr, 5));
1491                 {
1492                         uint32_t _flags_save_string = ndr->flags;
1493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1494                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1495                         ndr->flags = _flags_save_string;
1496                 }
1497                 {
1498                         uint32_t _flags_save_string = ndr->flags;
1499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1500                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1501                         ndr->flags = _flags_save_string;
1502                 }
1503                 {
1504                         uint32_t _flags_save_string = ndr->flags;
1505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1506                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1507                         ndr->flags = _flags_save_string;
1508                 }
1509                 {
1510                         uint32_t _flags_save_string = ndr->flags;
1511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1512                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1513                         ndr->flags = _flags_save_string;
1514                 }
1515                 {
1516                         uint32_t _flags_save_string = ndr->flags;
1517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1518                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1519                         ndr->flags = _flags_save_string;
1520                 }
1521                 {
1522                         uint32_t _flags_save_string = ndr->flags;
1523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1524                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1525                         ndr->flags = _flags_save_string;
1526                 }
1527                 {
1528                         uint32_t _flags_save_string = ndr->flags;
1529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1530                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1531                         ndr->flags = _flags_save_string;
1532                 }
1533                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1534                 {
1535                         uint32_t _flags_save_string = ndr->flags;
1536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1538                         ndr->flags = _flags_save_string;
1539                 }
1540                 {
1541                         uint32_t _flags_save_string = ndr->flags;
1542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1544                         ndr->flags = _flags_save_string;
1545                 }
1546                 {
1547                         uint32_t _flags_save_string = ndr->flags;
1548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1550                         ndr->flags = _flags_save_string;
1551                 }
1552                 {
1553                         uint32_t _flags_save_string = ndr->flags;
1554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1556                         ndr->flags = _flags_save_string;
1557                 }
1558                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1559                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1564                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1567                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1568         }
1569         if (ndr_flags & NDR_BUFFERS) {
1570                 {
1571                         uint32_t _flags_save_string = ndr->flags;
1572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1573                         if (r->servername) {
1574                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
1575                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1576                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
1577                         }
1578                         ndr->flags = _flags_save_string;
1579                 }
1580                 {
1581                         uint32_t _flags_save_string = ndr->flags;
1582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1583                         if (r->printername) {
1584                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
1585                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1586                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
1587                         }
1588                         ndr->flags = _flags_save_string;
1589                 }
1590                 {
1591                         uint32_t _flags_save_string = ndr->flags;
1592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1593                         if (r->sharename) {
1594                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sharename));
1595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1596                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sharename));
1597                         }
1598                         ndr->flags = _flags_save_string;
1599                 }
1600                 {
1601                         uint32_t _flags_save_string = ndr->flags;
1602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1603                         if (r->portname) {
1604                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
1605                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1606                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
1607                         }
1608                         ndr->flags = _flags_save_string;
1609                 }
1610                 {
1611                         uint32_t _flags_save_string = ndr->flags;
1612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1613                         if (r->drivername) {
1614                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->drivername));
1615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1616                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->drivername));
1617                         }
1618                         ndr->flags = _flags_save_string;
1619                 }
1620                 {
1621                         uint32_t _flags_save_string = ndr->flags;
1622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1623                         if (r->comment) {
1624                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1625                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1626                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1627                         }
1628                         ndr->flags = _flags_save_string;
1629                 }
1630                 {
1631                         uint32_t _flags_save_string = ndr->flags;
1632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1633                         if (r->location) {
1634                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->location));
1635                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1636                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->location));
1637                         }
1638                         ndr->flags = _flags_save_string;
1639                 }
1640                 if (r->devmode) {
1641                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
1642                         {
1643                                 struct ndr_push *_ndr_devmode;
1644                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1645                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1646                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1647                         }
1648                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
1649                 }
1650                 {
1651                         uint32_t _flags_save_string = ndr->flags;
1652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1653                         if (r->sepfile) {
1654                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sepfile));
1655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1656                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sepfile));
1657                         }
1658                         ndr->flags = _flags_save_string;
1659                 }
1660                 {
1661                         uint32_t _flags_save_string = ndr->flags;
1662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1663                         if (r->printprocessor) {
1664                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printprocessor));
1665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1666                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printprocessor));
1667                         }
1668                         ndr->flags = _flags_save_string;
1669                 }
1670                 {
1671                         uint32_t _flags_save_string = ndr->flags;
1672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1673                         if (r->datatype) {
1674                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->datatype));
1675                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1676                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->datatype));
1677                         }
1678                         ndr->flags = _flags_save_string;
1679                 }
1680                 {
1681                         uint32_t _flags_save_string = ndr->flags;
1682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1683                         if (r->parameters) {
1684                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
1685                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1686                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
1687                         }
1688                         ndr->flags = _flags_save_string;
1689                 }
1690                 if (r->secdesc) {
1691                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1692                         {
1693                                 struct ndr_push *_ndr_secdesc;
1694                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1695                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1696                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1697                         }
1698                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1699                 }
1700         }
1701         return NDR_ERR_SUCCESS;
1702 }
1703
1704 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1705 {
1706         uint32_t _ptr_servername;
1707         TALLOC_CTX *_mem_save_servername_0;
1708         uint32_t _ptr_printername;
1709         TALLOC_CTX *_mem_save_printername_0;
1710         uint32_t _ptr_sharename;
1711         TALLOC_CTX *_mem_save_sharename_0;
1712         uint32_t _ptr_portname;
1713         TALLOC_CTX *_mem_save_portname_0;
1714         uint32_t _ptr_drivername;
1715         TALLOC_CTX *_mem_save_drivername_0;
1716         uint32_t _ptr_comment;
1717         TALLOC_CTX *_mem_save_comment_0;
1718         uint32_t _ptr_location;
1719         TALLOC_CTX *_mem_save_location_0;
1720         uint32_t _ptr_devmode;
1721         TALLOC_CTX *_mem_save_devmode_0;
1722         uint32_t _ptr_sepfile;
1723         TALLOC_CTX *_mem_save_sepfile_0;
1724         uint32_t _ptr_printprocessor;
1725         TALLOC_CTX *_mem_save_printprocessor_0;
1726         uint32_t _ptr_datatype;
1727         TALLOC_CTX *_mem_save_datatype_0;
1728         uint32_t _ptr_parameters;
1729         TALLOC_CTX *_mem_save_parameters_0;
1730         uint32_t _ptr_secdesc;
1731         TALLOC_CTX *_mem_save_secdesc_0;
1732         if (ndr_flags & NDR_SCALARS) {
1733                 NDR_CHECK(ndr_pull_align(ndr, 5));
1734                 {
1735                         uint32_t _flags_save_string = ndr->flags;
1736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1737                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1738                         if (_ptr_servername) {
1739                                 NDR_PULL_ALLOC(ndr, r->servername);
1740                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1741                         } else {
1742                                 r->servername = NULL;
1743                         }
1744                         ndr->flags = _flags_save_string;
1745                 }
1746                 {
1747                         uint32_t _flags_save_string = ndr->flags;
1748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1749                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1750                         if (_ptr_printername) {
1751                                 NDR_PULL_ALLOC(ndr, r->printername);
1752                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1753                         } else {
1754                                 r->printername = NULL;
1755                         }
1756                         ndr->flags = _flags_save_string;
1757                 }
1758                 {
1759                         uint32_t _flags_save_string = ndr->flags;
1760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1761                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1762                         if (_ptr_sharename) {
1763                                 NDR_PULL_ALLOC(ndr, r->sharename);
1764                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1765                         } else {
1766                                 r->sharename = NULL;
1767                         }
1768                         ndr->flags = _flags_save_string;
1769                 }
1770                 {
1771                         uint32_t _flags_save_string = ndr->flags;
1772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1773                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1774                         if (_ptr_portname) {
1775                                 NDR_PULL_ALLOC(ndr, r->portname);
1776                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1777                         } else {
1778                                 r->portname = NULL;
1779                         }
1780                         ndr->flags = _flags_save_string;
1781                 }
1782                 {
1783                         uint32_t _flags_save_string = ndr->flags;
1784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1785                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1786                         if (_ptr_drivername) {
1787                                 NDR_PULL_ALLOC(ndr, r->drivername);
1788                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1789                         } else {
1790                                 r->drivername = NULL;
1791                         }
1792                         ndr->flags = _flags_save_string;
1793                 }
1794                 {
1795                         uint32_t _flags_save_string = ndr->flags;
1796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1797                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1798                         if (_ptr_comment) {
1799                                 NDR_PULL_ALLOC(ndr, r->comment);
1800                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1801                         } else {
1802                                 r->comment = NULL;
1803                         }
1804                         ndr->flags = _flags_save_string;
1805                 }
1806                 {
1807                         uint32_t _flags_save_string = ndr->flags;
1808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1809                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1810                         if (_ptr_location) {
1811                                 NDR_PULL_ALLOC(ndr, r->location);
1812                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1813                         } else {
1814                                 r->location = NULL;
1815                         }
1816                         ndr->flags = _flags_save_string;
1817                 }
1818                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1819                 if (_ptr_devmode) {
1820                         NDR_PULL_ALLOC(ndr, r->devmode);
1821                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1822                 } else {
1823                         r->devmode = NULL;
1824                 }
1825                 {
1826                         uint32_t _flags_save_string = ndr->flags;
1827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1828                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1829                         if (_ptr_sepfile) {
1830                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1831                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1832                         } else {
1833                                 r->sepfile = NULL;
1834                         }
1835                         ndr->flags = _flags_save_string;
1836                 }
1837                 {
1838                         uint32_t _flags_save_string = ndr->flags;
1839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1840                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1841                         if (_ptr_printprocessor) {
1842                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1843                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1844                         } else {
1845                                 r->printprocessor = NULL;
1846                         }
1847                         ndr->flags = _flags_save_string;
1848                 }
1849                 {
1850                         uint32_t _flags_save_string = ndr->flags;
1851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1852                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1853                         if (_ptr_datatype) {
1854                                 NDR_PULL_ALLOC(ndr, r->datatype);
1855                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1856                         } else {
1857                                 r->datatype = NULL;
1858                         }
1859                         ndr->flags = _flags_save_string;
1860                 }
1861                 {
1862                         uint32_t _flags_save_string = ndr->flags;
1863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1864                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1865                         if (_ptr_parameters) {
1866                                 NDR_PULL_ALLOC(ndr, r->parameters);
1867                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1868                         } else {
1869                                 r->parameters = NULL;
1870                         }
1871                         ndr->flags = _flags_save_string;
1872                 }
1873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1874                 if (_ptr_secdesc) {
1875                         NDR_PULL_ALLOC(ndr, r->secdesc);
1876                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1877                 } else {
1878                         r->secdesc = NULL;
1879                 }
1880                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1882                 if (r->priority > 99) {
1883                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1884                 }
1885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1888                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1891                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1892         }
1893         if (ndr_flags & NDR_BUFFERS) {
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         if (r->servername) {
1898                                 uint32_t _relative_save_offset;
1899                                 _relative_save_offset = ndr->offset;
1900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1901                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1902                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1905                                 if (ndr->offset > ndr->relative_highest_offset) {
1906                                         ndr->relative_highest_offset = ndr->offset;
1907                                 }
1908                                 ndr->offset = _relative_save_offset;
1909                         }
1910                         ndr->flags = _flags_save_string;
1911                 }
1912                 {
1913                         uint32_t _flags_save_string = ndr->flags;
1914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1915                         if (r->printername) {
1916                                 uint32_t _relative_save_offset;
1917                                 _relative_save_offset = ndr->offset;
1918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1919                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1920                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1923                                 if (ndr->offset > ndr->relative_highest_offset) {
1924                                         ndr->relative_highest_offset = ndr->offset;
1925                                 }
1926                                 ndr->offset = _relative_save_offset;
1927                         }
1928                         ndr->flags = _flags_save_string;
1929                 }
1930                 {
1931                         uint32_t _flags_save_string = ndr->flags;
1932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1933                         if (r->sharename) {
1934                                 uint32_t _relative_save_offset;
1935                                 _relative_save_offset = ndr->offset;
1936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1937                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1938                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1941                                 if (ndr->offset > ndr->relative_highest_offset) {
1942                                         ndr->relative_highest_offset = ndr->offset;
1943                                 }
1944                                 ndr->offset = _relative_save_offset;
1945                         }
1946                         ndr->flags = _flags_save_string;
1947                 }
1948                 {
1949                         uint32_t _flags_save_string = ndr->flags;
1950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1951                         if (r->portname) {
1952                                 uint32_t _relative_save_offset;
1953                                 _relative_save_offset = ndr->offset;
1954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1955                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1956                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1959                                 if (ndr->offset > ndr->relative_highest_offset) {
1960                                         ndr->relative_highest_offset = ndr->offset;
1961                                 }
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966                 {
1967                         uint32_t _flags_save_string = ndr->flags;
1968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1969                         if (r->drivername) {
1970                                 uint32_t _relative_save_offset;
1971                                 _relative_save_offset = ndr->offset;
1972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1973                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1974                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1977                                 if (ndr->offset > ndr->relative_highest_offset) {
1978                                         ndr->relative_highest_offset = ndr->offset;
1979                                 }
1980                                 ndr->offset = _relative_save_offset;
1981                         }
1982                         ndr->flags = _flags_save_string;
1983                 }
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->comment) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1991                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1995                                 if (ndr->offset > ndr->relative_highest_offset) {
1996                                         ndr->relative_highest_offset = ndr->offset;
1997                                 }
1998                                 ndr->offset = _relative_save_offset;
1999                         }
2000                         ndr->flags = _flags_save_string;
2001                 }
2002                 {
2003                         uint32_t _flags_save_string = ndr->flags;
2004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2005                         if (r->location) {
2006                                 uint32_t _relative_save_offset;
2007                                 _relative_save_offset = ndr->offset;
2008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
2009                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
2010                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
2011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
2012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
2013                                 if (ndr->offset > ndr->relative_highest_offset) {
2014                                         ndr->relative_highest_offset = ndr->offset;
2015                                 }
2016                                 ndr->offset = _relative_save_offset;
2017                         }
2018                         ndr->flags = _flags_save_string;
2019                 }
2020                 if (r->devmode) {
2021                         uint32_t _relative_save_offset;
2022                         _relative_save_offset = ndr->offset;
2023                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2024                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2025                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2026                         {
2027                                 struct ndr_pull *_ndr_devmode;
2028                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2029                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2030                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2031                         }
2032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2033                         if (ndr->offset > ndr->relative_highest_offset) {
2034                                 ndr->relative_highest_offset = ndr->offset;
2035                         }
2036                         ndr->offset = _relative_save_offset;
2037                 }
2038                 {
2039                         uint32_t _flags_save_string = ndr->flags;
2040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2041                         if (r->sepfile) {
2042                                 uint32_t _relative_save_offset;
2043                                 _relative_save_offset = ndr->offset;
2044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
2045                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
2046                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
2047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
2048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
2049                                 if (ndr->offset > ndr->relative_highest_offset) {
2050                                         ndr->relative_highest_offset = ndr->offset;
2051                                 }
2052                                 ndr->offset = _relative_save_offset;
2053                         }
2054                         ndr->flags = _flags_save_string;
2055                 }
2056                 {
2057                         uint32_t _flags_save_string = ndr->flags;
2058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2059                         if (r->printprocessor) {
2060                                 uint32_t _relative_save_offset;
2061                                 _relative_save_offset = ndr->offset;
2062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2063                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2064                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2067                                 if (ndr->offset > ndr->relative_highest_offset) {
2068                                         ndr->relative_highest_offset = ndr->offset;
2069                                 }
2070                                 ndr->offset = _relative_save_offset;
2071                         }
2072                         ndr->flags = _flags_save_string;
2073                 }
2074                 {
2075                         uint32_t _flags_save_string = ndr->flags;
2076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2077                         if (r->datatype) {
2078                                 uint32_t _relative_save_offset;
2079                                 _relative_save_offset = ndr->offset;
2080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2081                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2082                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2085                                 if (ndr->offset > ndr->relative_highest_offset) {
2086                                         ndr->relative_highest_offset = ndr->offset;
2087                                 }
2088                                 ndr->offset = _relative_save_offset;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 {
2093                         uint32_t _flags_save_string = ndr->flags;
2094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2095                         if (r->parameters) {
2096                                 uint32_t _relative_save_offset;
2097                                 _relative_save_offset = ndr->offset;
2098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2099                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2100                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2103                                 if (ndr->offset > ndr->relative_highest_offset) {
2104                                         ndr->relative_highest_offset = ndr->offset;
2105                                 }
2106                                 ndr->offset = _relative_save_offset;
2107                         }
2108                         ndr->flags = _flags_save_string;
2109                 }
2110                 if (r->secdesc) {
2111                         uint32_t _relative_save_offset;
2112                         _relative_save_offset = ndr->offset;
2113                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2114                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2115                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2116                         {
2117                                 struct ndr_pull *_ndr_secdesc;
2118                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2119                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2120                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2121                         }
2122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2123                         if (ndr->offset > ndr->relative_highest_offset) {
2124                                 ndr->relative_highest_offset = ndr->offset;
2125                         }
2126                         ndr->offset = _relative_save_offset;
2127                 }
2128         }
2129         return NDR_ERR_SUCCESS;
2130 }
2131
2132 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2133 {
2134         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2135         ndr->depth++;
2136         ndr_print_ptr(ndr, "servername", r->servername);
2137         ndr->depth++;
2138         if (r->servername) {
2139                 ndr_print_string(ndr, "servername", r->servername);
2140         }
2141         ndr->depth--;
2142         ndr_print_ptr(ndr, "printername", r->printername);
2143         ndr->depth++;
2144         if (r->printername) {
2145                 ndr_print_string(ndr, "printername", r->printername);
2146         }
2147         ndr->depth--;
2148         ndr_print_ptr(ndr, "sharename", r->sharename);
2149         ndr->depth++;
2150         if (r->sharename) {
2151                 ndr_print_string(ndr, "sharename", r->sharename);
2152         }
2153         ndr->depth--;
2154         ndr_print_ptr(ndr, "portname", r->portname);
2155         ndr->depth++;
2156         if (r->portname) {
2157                 ndr_print_string(ndr, "portname", r->portname);
2158         }
2159         ndr->depth--;
2160         ndr_print_ptr(ndr, "drivername", r->drivername);
2161         ndr->depth++;
2162         if (r->drivername) {
2163                 ndr_print_string(ndr, "drivername", r->drivername);
2164         }
2165         ndr->depth--;
2166         ndr_print_ptr(ndr, "comment", r->comment);
2167         ndr->depth++;
2168         if (r->comment) {
2169                 ndr_print_string(ndr, "comment", r->comment);
2170         }
2171         ndr->depth--;
2172         ndr_print_ptr(ndr, "location", r->location);
2173         ndr->depth++;
2174         if (r->location) {
2175                 ndr_print_string(ndr, "location", r->location);
2176         }
2177         ndr->depth--;
2178         ndr_print_ptr(ndr, "devmode", r->devmode);
2179         ndr->depth++;
2180         if (r->devmode) {
2181                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2182         }
2183         ndr->depth--;
2184         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2185         ndr->depth++;
2186         if (r->sepfile) {
2187                 ndr_print_string(ndr, "sepfile", r->sepfile);
2188         }
2189         ndr->depth--;
2190         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2191         ndr->depth++;
2192         if (r->printprocessor) {
2193                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2194         }
2195         ndr->depth--;
2196         ndr_print_ptr(ndr, "datatype", r->datatype);
2197         ndr->depth++;
2198         if (r->datatype) {
2199                 ndr_print_string(ndr, "datatype", r->datatype);
2200         }
2201         ndr->depth--;
2202         ndr_print_ptr(ndr, "parameters", r->parameters);
2203         ndr->depth++;
2204         if (r->parameters) {
2205                 ndr_print_string(ndr, "parameters", r->parameters);
2206         }
2207         ndr->depth--;
2208         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2209         ndr->depth++;
2210         if (r->secdesc) {
2211                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2212         }
2213         ndr->depth--;
2214         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2215         ndr_print_uint32(ndr, "priority", r->priority);
2216         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2217         ndr_print_uint32(ndr, "starttime", r->starttime);
2218         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2219         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2220         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2221         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2222         ndr->depth--;
2223 }
2224
2225 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2226 {
2227         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2228 }
2229
2230 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2231 {
2232         if (ndr_flags & NDR_SCALARS) {
2233                 NDR_CHECK(ndr_push_align(ndr, 5));
2234                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2235                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2236         }
2237         if (ndr_flags & NDR_BUFFERS) {
2238                 if (r->secdesc) {
2239                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
2240                         {
2241                                 struct ndr_push *_ndr_secdesc;
2242                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2243                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2244                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2245                         }
2246                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
2247                 }
2248         }
2249         return NDR_ERR_SUCCESS;
2250 }
2251
2252 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2253 {
2254         uint32_t _ptr_secdesc;
2255         TALLOC_CTX *_mem_save_secdesc_0;
2256         if (ndr_flags & NDR_SCALARS) {
2257                 NDR_CHECK(ndr_pull_align(ndr, 5));
2258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2259                 if (_ptr_secdesc) {
2260                         NDR_PULL_ALLOC(ndr, r->secdesc);
2261                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2262                 } else {
2263                         r->secdesc = NULL;
2264                 }
2265                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2266         }
2267         if (ndr_flags & NDR_BUFFERS) {
2268                 if (r->secdesc) {
2269                         uint32_t _relative_save_offset;
2270                         _relative_save_offset = ndr->offset;
2271                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2272                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2273                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2274                         {
2275                                 struct ndr_pull *_ndr_secdesc;
2276                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2277                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2278                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2279                         }
2280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2281                         if (ndr->offset > ndr->relative_highest_offset) {
2282                                 ndr->relative_highest_offset = ndr->offset;
2283                         }
2284                         ndr->offset = _relative_save_offset;
2285                 }
2286         }
2287         return NDR_ERR_SUCCESS;
2288 }
2289
2290 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2291 {
2292         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2293         ndr->depth++;
2294         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2295         ndr->depth++;
2296         if (r->secdesc) {
2297                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2298         }
2299         ndr->depth--;
2300         ndr->depth--;
2301 }
2302
2303 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2304 {
2305         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2306 }
2307
2308 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2309 {
2310         if (ndr_flags & NDR_SCALARS) {
2311                 NDR_CHECK(ndr_push_align(ndr, 5));
2312                 {
2313                         uint32_t _flags_save_string = ndr->flags;
2314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2315                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2316                         ndr->flags = _flags_save_string;
2317                 }
2318                 {
2319                         uint32_t _flags_save_string = ndr->flags;
2320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2321                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2322                         ndr->flags = _flags_save_string;
2323                 }
2324                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2325                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2326         }
2327         if (ndr_flags & NDR_BUFFERS) {
2328                 {
2329                         uint32_t _flags_save_string = ndr->flags;
2330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2331                         if (r->printername) {
2332                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2333                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2334                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2335                         }
2336                         ndr->flags = _flags_save_string;
2337                 }
2338                 {
2339                         uint32_t _flags_save_string = ndr->flags;
2340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2341                         if (r->servername) {
2342                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
2343                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2344                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
2345                         }
2346                         ndr->flags = _flags_save_string;
2347                 }
2348         }
2349         return NDR_ERR_SUCCESS;
2350 }
2351
2352 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2353 {
2354         uint32_t _ptr_printername;
2355         TALLOC_CTX *_mem_save_printername_0;
2356         uint32_t _ptr_servername;
2357         TALLOC_CTX *_mem_save_servername_0;
2358         if (ndr_flags & NDR_SCALARS) {
2359                 NDR_CHECK(ndr_pull_align(ndr, 5));
2360                 {
2361                         uint32_t _flags_save_string = ndr->flags;
2362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2363                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2364                         if (_ptr_printername) {
2365                                 NDR_PULL_ALLOC(ndr, r->printername);
2366                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2367                         } else {
2368                                 r->printername = NULL;
2369                         }
2370                         ndr->flags = _flags_save_string;
2371                 }
2372                 {
2373                         uint32_t _flags_save_string = ndr->flags;
2374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2376                         if (_ptr_servername) {
2377                                 NDR_PULL_ALLOC(ndr, r->servername);
2378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2379                         } else {
2380                                 r->servername = NULL;
2381                         }
2382                         ndr->flags = _flags_save_string;
2383                 }
2384                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2385                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2386         }
2387         if (ndr_flags & NDR_BUFFERS) {
2388                 {
2389                         uint32_t _flags_save_string = ndr->flags;
2390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2391                         if (r->printername) {
2392                                 uint32_t _relative_save_offset;
2393                                 _relative_save_offset = ndr->offset;
2394                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2395                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2396                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2397                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2398                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2399                                 if (ndr->offset > ndr->relative_highest_offset) {
2400                                         ndr->relative_highest_offset = ndr->offset;
2401                                 }
2402                                 ndr->offset = _relative_save_offset;
2403                         }
2404                         ndr->flags = _flags_save_string;
2405                 }
2406                 {
2407                         uint32_t _flags_save_string = ndr->flags;
2408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2409                         if (r->servername) {
2410                                 uint32_t _relative_save_offset;
2411                                 _relative_save_offset = ndr->offset;
2412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2413                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2414                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2417                                 if (ndr->offset > ndr->relative_highest_offset) {
2418                                         ndr->relative_highest_offset = ndr->offset;
2419                                 }
2420                                 ndr->offset = _relative_save_offset;
2421                         }
2422                         ndr->flags = _flags_save_string;
2423                 }
2424         }
2425         return NDR_ERR_SUCCESS;
2426 }
2427
2428 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2429 {
2430         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2431         ndr->depth++;
2432         ndr_print_ptr(ndr, "printername", r->printername);
2433         ndr->depth++;
2434         if (r->printername) {
2435                 ndr_print_string(ndr, "printername", r->printername);
2436         }
2437         ndr->depth--;
2438         ndr_print_ptr(ndr, "servername", r->servername);
2439         ndr->depth++;
2440         if (r->servername) {
2441                 ndr_print_string(ndr, "servername", r->servername);
2442         }
2443         ndr->depth--;
2444         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2445         ndr->depth--;
2446 }
2447
2448 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2449 {
2450         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2451 }
2452
2453 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2454 {
2455         if (ndr_flags & NDR_SCALARS) {
2456                 NDR_CHECK(ndr_push_align(ndr, 5));
2457                 {
2458                         uint32_t _flags_save_string = ndr->flags;
2459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2460                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2461                         ndr->flags = _flags_save_string;
2462                 }
2463                 {
2464                         uint32_t _flags_save_string = ndr->flags;
2465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2466                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2467                         ndr->flags = _flags_save_string;
2468                 }
2469                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2472                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2473         }
2474         if (ndr_flags & NDR_BUFFERS) {
2475                 {
2476                         uint32_t _flags_save_string = ndr->flags;
2477                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2478                         if (r->printername) {
2479                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2480                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2481                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2482                         }
2483                         ndr->flags = _flags_save_string;
2484                 }
2485                 {
2486                         uint32_t _flags_save_string = ndr->flags;
2487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2488                         if (r->portname) {
2489                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
2490                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2491                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
2492                         }
2493                         ndr->flags = _flags_save_string;
2494                 }
2495         }
2496         return NDR_ERR_SUCCESS;
2497 }
2498
2499 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2500 {
2501         uint32_t _ptr_printername;
2502         TALLOC_CTX *_mem_save_printername_0;
2503         uint32_t _ptr_portname;
2504         TALLOC_CTX *_mem_save_portname_0;
2505         if (ndr_flags & NDR_SCALARS) {
2506                 NDR_CHECK(ndr_pull_align(ndr, 5));
2507                 {
2508                         uint32_t _flags_save_string = ndr->flags;
2509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2510                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2511                         if (_ptr_printername) {
2512                                 NDR_PULL_ALLOC(ndr, r->printername);
2513                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2514                         } else {
2515                                 r->printername = NULL;
2516                         }
2517                         ndr->flags = _flags_save_string;
2518                 }
2519                 {
2520                         uint32_t _flags_save_string = ndr->flags;
2521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2522                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2523                         if (_ptr_portname) {
2524                                 NDR_PULL_ALLOC(ndr, r->portname);
2525                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2526                         } else {
2527                                 r->portname = NULL;
2528                         }
2529                         ndr->flags = _flags_save_string;
2530                 }
2531                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2534                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2535         }
2536         if (ndr_flags & NDR_BUFFERS) {
2537                 {
2538                         uint32_t _flags_save_string = ndr->flags;
2539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2540                         if (r->printername) {
2541                                 uint32_t _relative_save_offset;
2542                                 _relative_save_offset = ndr->offset;
2543                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2544                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2545                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2546                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2547                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2548                                 if (ndr->offset > ndr->relative_highest_offset) {
2549                                         ndr->relative_highest_offset = ndr->offset;
2550                                 }
2551                                 ndr->offset = _relative_save_offset;
2552                         }
2553                         ndr->flags = _flags_save_string;
2554                 }
2555                 {
2556                         uint32_t _flags_save_string = ndr->flags;
2557                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2558                         if (r->portname) {
2559                                 uint32_t _relative_save_offset;
2560                                 _relative_save_offset = ndr->offset;
2561                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2562                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2563                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2564                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2565                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2566                                 if (ndr->offset > ndr->relative_highest_offset) {
2567                                         ndr->relative_highest_offset = ndr->offset;
2568                                 }
2569                                 ndr->offset = _relative_save_offset;
2570                         }
2571                         ndr->flags = _flags_save_string;
2572                 }
2573         }
2574         return NDR_ERR_SUCCESS;
2575 }
2576
2577 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2578 {
2579         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2580         ndr->depth++;
2581         ndr_print_ptr(ndr, "printername", r->printername);
2582         ndr->depth++;
2583         if (r->printername) {
2584                 ndr_print_string(ndr, "printername", r->printername);
2585         }
2586         ndr->depth--;
2587         ndr_print_ptr(ndr, "portname", r->portname);
2588         ndr->depth++;
2589         if (r->portname) {
2590                 ndr_print_string(ndr, "portname", r->portname);
2591         }
2592         ndr->depth--;
2593         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2594         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2595         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2596         ndr->depth--;
2597 }
2598
2599 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2600 {
2601         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2602 }
2603
2604 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2605 {
2606         if (ndr_flags & NDR_SCALARS) {
2607                 NDR_CHECK(ndr_push_align(ndr, 4));
2608                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2609                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2610         }
2611         if (ndr_flags & NDR_BUFFERS) {
2612         }
2613         return NDR_ERR_SUCCESS;
2614 }
2615
2616 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2617 {
2618         if (ndr_flags & NDR_SCALARS) {
2619                 NDR_CHECK(ndr_pull_align(ndr, 4));
2620                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2621                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2622         }
2623         if (ndr_flags & NDR_BUFFERS) {
2624         }
2625         return NDR_ERR_SUCCESS;
2626 }
2627
2628 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2629 {
2630         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2631         ndr->depth++;
2632         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2633         ndr->depth--;
2634 }
2635
2636 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2637 {
2638         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2639 }
2640
2641 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2642 {
2643         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2644         return NDR_ERR_SUCCESS;
2645 }
2646
2647 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2648 {
2649         uint32_t v;
2650         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2651         *r = v;
2652         return NDR_ERR_SUCCESS;
2653 }
2654
2655 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2656 {
2657         ndr_print_uint32(ndr, name, r);
2658         ndr->depth++;
2659         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2660         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2664         ndr->depth--;
2665 }
2666
2667 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2668 {
2669         if (ndr_flags & NDR_SCALARS) {
2670                 NDR_CHECK(ndr_push_align(ndr, 5));
2671                 {
2672                         uint32_t _flags_save_string = ndr->flags;
2673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2674                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2675                         ndr->flags = _flags_save_string;
2676                 }
2677                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2678                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2679         }
2680         if (ndr_flags & NDR_BUFFERS) {
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         if (r->guid) {
2685                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->guid));
2686                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2687                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->guid));
2688                         }
2689                         ndr->flags = _flags_save_string;
2690                 }
2691         }
2692         return NDR_ERR_SUCCESS;
2693 }
2694
2695 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2696 {
2697         uint32_t _ptr_guid;
2698         TALLOC_CTX *_mem_save_guid_0;
2699         if (ndr_flags & NDR_SCALARS) {
2700                 NDR_CHECK(ndr_pull_align(ndr, 5));
2701                 {
2702                         uint32_t _flags_save_string = ndr->flags;
2703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2704                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2705                         if (_ptr_guid) {
2706                                 NDR_PULL_ALLOC(ndr, r->guid);
2707                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2708                         } else {
2709                                 r->guid = NULL;
2710                         }
2711                         ndr->flags = _flags_save_string;
2712                 }
2713                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2714                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2715         }
2716         if (ndr_flags & NDR_BUFFERS) {
2717                 {
2718                         uint32_t _flags_save_string = ndr->flags;
2719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2720                         if (r->guid) {
2721                                 uint32_t _relative_save_offset;
2722                                 _relative_save_offset = ndr->offset;
2723                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2724                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2725                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2726                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2727                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2728                                 if (ndr->offset > ndr->relative_highest_offset) {
2729                                         ndr->relative_highest_offset = ndr->offset;
2730                                 }
2731                                 ndr->offset = _relative_save_offset;
2732                         }
2733                         ndr->flags = _flags_save_string;
2734                 }
2735         }
2736         return NDR_ERR_SUCCESS;
2737 }
2738
2739 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2740 {
2741         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2742         ndr->depth++;
2743         ndr_print_ptr(ndr, "guid", r->guid);
2744         ndr->depth++;
2745         if (r->guid) {
2746                 ndr_print_string(ndr, "guid", r->guid);
2747         }
2748         ndr->depth--;
2749         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2750         ndr->depth--;
2751 }
2752
2753 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2754 {
2755         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2756 }
2757
2758 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2759 {
2760         if (ndr_flags & NDR_SCALARS) {
2761                 NDR_CHECK(ndr_push_align(ndr, 5));
2762                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2763                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2764         }
2765         if (ndr_flags & NDR_BUFFERS) {
2766                 if (r->devmode) {
2767                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
2768                         {
2769                                 struct ndr_push *_ndr_devmode;
2770                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2771                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2772                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2773                         }
2774                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
2775                 }
2776         }
2777         return NDR_ERR_SUCCESS;
2778 }
2779
2780 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2781 {
2782         uint32_t _ptr_devmode;
2783         TALLOC_CTX *_mem_save_devmode_0;
2784         if (ndr_flags & NDR_SCALARS) {
2785                 NDR_CHECK(ndr_pull_align(ndr, 5));
2786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2787                 if (_ptr_devmode) {
2788                         NDR_PULL_ALLOC(ndr, r->devmode);
2789                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2790                 } else {
2791                         r->devmode = NULL;
2792                 }
2793                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2794         }
2795         if (ndr_flags & NDR_BUFFERS) {
2796                 if (r->devmode) {
2797                         uint32_t _relative_save_offset;
2798                         _relative_save_offset = ndr->offset;
2799                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2800                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2801                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2802                         {
2803                                 struct ndr_pull *_ndr_devmode;
2804                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2805                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2806                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2807                         }
2808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2809                         if (ndr->offset > ndr->relative_highest_offset) {
2810                                 ndr->relative_highest_offset = ndr->offset;
2811                         }
2812                         ndr->offset = _relative_save_offset;
2813                 }
2814         }
2815         return NDR_ERR_SUCCESS;
2816 }
2817
2818 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2819 {
2820         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2821         ndr->depth++;
2822         ndr_print_ptr(ndr, "devmode", r->devmode);
2823         ndr->depth++;
2824         if (r->devmode) {
2825                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2826         }
2827         ndr->depth--;
2828         ndr->depth--;
2829 }
2830
2831 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2832 {
2833         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2834         if (ndr_flags & NDR_SCALARS) {
2835                 int level = ndr_push_get_switch_value(ndr, r);
2836                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2837                 switch (level) {
2838                         case 0: {
2839                                 NDR_CHECK(ndr_push_align(ndr, 5));
2840                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2841                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2842                         break; }
2843
2844                         case 1: {
2845                                 NDR_CHECK(ndr_push_align(ndr, 5));
2846                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2847                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2848                         break; }
2849
2850                         case 2: {
2851                                 NDR_CHECK(ndr_push_align(ndr, 5));
2852                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2853                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2854                         break; }
2855
2856                         case 3: {
2857                                 NDR_CHECK(ndr_push_align(ndr, 5));
2858                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2859                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2860                         break; }
2861
2862                         case 4: {
2863                                 NDR_CHECK(ndr_push_align(ndr, 5));
2864                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2865                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2866                         break; }
2867
2868                         case 5: {
2869                                 NDR_CHECK(ndr_push_align(ndr, 5));
2870                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2871                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2872                         break; }
2873
2874                         case 6: {
2875                                 NDR_CHECK(ndr_push_align(ndr, 4));
2876                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2877                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2878                         break; }
2879
2880                         case 7: {
2881                                 NDR_CHECK(ndr_push_align(ndr, 5));
2882                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2883                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2884                         break; }
2885
2886                         case 8: {
2887                                 NDR_CHECK(ndr_push_align(ndr, 5));
2888                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2889                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2890                         break; }
2891
2892                         case 9: {
2893                                 NDR_CHECK(ndr_push_align(ndr, 5));
2894                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2895                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2896                         break; }
2897
2898                         default: {
2899                         break; }
2900
2901                 }
2902         }
2903         if (ndr_flags & NDR_BUFFERS) {
2904                 int level = ndr_push_get_switch_value(ndr, r);
2905                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2906                 switch (level) {
2907                         case 0:
2908                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2909                         break;
2910
2911                         case 1:
2912                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2913                         break;
2914
2915                         case 2:
2916                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2917                         break;
2918
2919                         case 3:
2920                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2921                         break;
2922
2923                         case 4:
2924                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2925                         break;
2926
2927                         case 5:
2928                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2929                         break;
2930
2931                         case 6:
2932                         break;
2933
2934                         case 7:
2935                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2936                         break;
2937
2938                         case 8:
2939                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2940                         break;
2941
2942                         case 9:
2943                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2944                         break;
2945
2946                         default:
2947                         break;
2948
2949                 }
2950         }
2951         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2952         return NDR_ERR_SUCCESS;
2953 }
2954
2955 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2956 {
2957         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2958         int level;
2959         level = ndr_pull_get_switch_value(ndr, r);
2960         if (ndr_flags & NDR_SCALARS) {
2961                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2962                 switch (level) {
2963                         case 0: {
2964                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2965                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2966                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2967                         break; }
2968
2969                         case 1: {
2970                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2971                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2972                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2973                         break; }
2974
2975                         case 2: {
2976                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2977                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2978                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2979                         break; }
2980
2981                         case 3: {
2982                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2983                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2984                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2985                         break; }
2986
2987                         case 4: {
2988                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2989                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2990                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2991                         break; }
2992
2993                         case 5: {
2994                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2995                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2996                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2997                         break; }
2998
2999                         case 6: {
3000                                 NDR_CHECK(ndr_pull_align(ndr, 4));
3001                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3002                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
3003                         break; }
3004
3005                         case 7: {
3006                                 NDR_CHECK(ndr_pull_align(ndr, 5));
3007                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3008                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
3009                         break; }
3010
3011                         case 8: {
3012                                 NDR_CHECK(ndr_pull_align(ndr, 5));
3013                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3014                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
3015                         break; }
3016
3017                         case 9: {
3018                                 NDR_CHECK(ndr_pull_align(ndr, 5));
3019                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3020                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
3021                         break; }
3022
3023                         default: {
3024                         break; }
3025
3026                 }
3027         }
3028         if (ndr_flags & NDR_BUFFERS) {
3029                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
3030                 switch (level) {
3031                         case 0:
3032                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3033                         break;
3034
3035                         case 1:
3036                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3037                         break;
3038
3039                         case 2:
3040                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3041                         break;
3042
3043                         case 3:
3044                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3045                         break;
3046
3047                         case 4:
3048                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3049                         break;
3050
3051                         case 5:
3052                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3053                         break;
3054
3055                         case 6:
3056                         break;
3057
3058                         case 7:
3059                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3060                         break;
3061
3062                         case 8:
3063                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3064                         break;
3065
3066                         case 9:
3067                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3068                         break;
3069
3070                         default:
3071                         break;
3072
3073                 }
3074         }
3075         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
3076         return NDR_ERR_SUCCESS;
3077 }
3078
3079 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
3080 {
3081         int level;
3082         level = ndr_print_get_switch_value(ndr, r);
3083         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
3084         switch (level) {
3085                 case 0:
3086                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
3087                 break;
3088
3089                 case 1:
3090                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
3091                 break;
3092
3093                 case 2:
3094                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
3095                 break;
3096
3097                 case 3:
3098                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
3099                 break;
3100
3101                 case 4:
3102                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3103                 break;
3104
3105                 case 5:
3106                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3107                 break;
3108
3109                 case 6:
3110                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3111                 break;
3112
3113                 case 7:
3114                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3115                 break;
3116
3117                 case 8:
3118                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3119                 break;
3120
3121                 case 9:
3122                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3123                 break;
3124
3125                 default:
3126                 break;
3127
3128         }
3129 }
3130
3131 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3132 {
3133         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3134 }
3135
3136 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3137 {
3138         if (ndr_flags & NDR_SCALARS) {
3139                 NDR_CHECK(ndr_push_align(ndr, 5));
3140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3141                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3142                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3143         }
3144         if (ndr_flags & NDR_BUFFERS) {
3145                 if (r->devmode) {
3146                         {
3147                                 struct ndr_push *_ndr_devmode;
3148                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3149                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3150                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3151                         }
3152                 }
3153         }
3154         return NDR_ERR_SUCCESS;
3155 }
3156
3157 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3158 {
3159         uint32_t _ptr_devmode;
3160         TALLOC_CTX *_mem_save_devmode_0;
3161         if (ndr_flags & NDR_SCALARS) {
3162                 NDR_CHECK(ndr_pull_align(ndr, 5));
3163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3165                 if (_ptr_devmode) {
3166                         NDR_PULL_ALLOC(ndr, r->devmode);
3167                 } else {
3168                         r->devmode = NULL;
3169                 }
3170                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3171         }
3172         if (ndr_flags & NDR_BUFFERS) {
3173                 if (r->devmode) {
3174                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3175                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3176                         {
3177                                 struct ndr_pull *_ndr_devmode;
3178                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3179                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3180                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3181                         }
3182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3183                 }
3184         }
3185         return NDR_ERR_SUCCESS;
3186 }
3187
3188 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3189 {
3190         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3191         ndr->depth++;
3192         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);
3193         ndr_print_ptr(ndr, "devmode", r->devmode);
3194         ndr->depth++;
3195         if (r->devmode) {
3196                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3197         }
3198         ndr->depth--;
3199         ndr->depth--;
3200 }
3201
3202 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3203 {
3204         if (ndr_flags & NDR_SCALARS) {
3205                 NDR_CHECK(ndr_push_align(ndr, 5));
3206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3207                 {
3208                         uint32_t _flags_save_string = ndr->flags;
3209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3210                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3211                         ndr->flags = _flags_save_string;
3212                 }
3213                 {
3214                         uint32_t _flags_save_string = ndr->flags;
3215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3216                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3217                         ndr->flags = _flags_save_string;
3218                 }
3219                 {
3220                         uint32_t _flags_save_string = ndr->flags;
3221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3222                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3223                         ndr->flags = _flags_save_string;
3224                 }
3225                 {
3226                         uint32_t _flags_save_string = ndr->flags;
3227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3228                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3229                         ndr->flags = _flags_save_string;
3230                 }
3231                 {
3232                         uint32_t _flags_save_string = ndr->flags;
3233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3235                         ndr->flags = _flags_save_string;
3236                 }
3237                 {
3238                         uint32_t _flags_save_string = ndr->flags;
3239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3241                         ndr->flags = _flags_save_string;
3242                 }
3243                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3248                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3249                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3250         }
3251         if (ndr_flags & NDR_BUFFERS) {
3252                 {
3253                         uint32_t _flags_save_string = ndr->flags;
3254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3255                         if (r->printer_name) {
3256                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3257                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3258                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3259                         }
3260                         ndr->flags = _flags_save_string;
3261                 }
3262                 {
3263                         uint32_t _flags_save_string = ndr->flags;
3264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3265                         if (r->server_name) {
3266                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3267                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3268                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3269                         }
3270                         ndr->flags = _flags_save_string;
3271                 }
3272                 {
3273                         uint32_t _flags_save_string = ndr->flags;
3274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3275                         if (r->user_name) {
3276                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3278                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3279                         }
3280                         ndr->flags = _flags_save_string;
3281                 }
3282                 {
3283                         uint32_t _flags_save_string = ndr->flags;
3284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3285                         if (r->document_name) {
3286                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3287                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3288                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3289                         }
3290                         ndr->flags = _flags_save_string;
3291                 }
3292                 {
3293                         uint32_t _flags_save_string = ndr->flags;
3294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3295                         if (r->data_type) {
3296                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3297                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3298                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3299                         }
3300                         ndr->flags = _flags_save_string;
3301                 }
3302                 {
3303                         uint32_t _flags_save_string = ndr->flags;
3304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3305                         if (r->text_status) {
3306                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3307                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3308                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3309                         }
3310                         ndr->flags = _flags_save_string;
3311                 }
3312         }
3313         return NDR_ERR_SUCCESS;
3314 }
3315
3316 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3317 {
3318         uint32_t _ptr_printer_name;
3319         TALLOC_CTX *_mem_save_printer_name_0;
3320         uint32_t _ptr_server_name;
3321         TALLOC_CTX *_mem_save_server_name_0;
3322         uint32_t _ptr_user_name;
3323         TALLOC_CTX *_mem_save_user_name_0;
3324         uint32_t _ptr_document_name;
3325         TALLOC_CTX *_mem_save_document_name_0;
3326         uint32_t _ptr_data_type;
3327         TALLOC_CTX *_mem_save_data_type_0;
3328         uint32_t _ptr_text_status;
3329         TALLOC_CTX *_mem_save_text_status_0;
3330         if (ndr_flags & NDR_SCALARS) {
3331                 NDR_CHECK(ndr_pull_align(ndr, 5));
3332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3333                 {
3334                         uint32_t _flags_save_string = ndr->flags;
3335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3336                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3337                         if (_ptr_printer_name) {
3338                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3339                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3340                         } else {
3341                                 r->printer_name = NULL;
3342                         }
3343                         ndr->flags = _flags_save_string;
3344                 }
3345                 {
3346                         uint32_t _flags_save_string = ndr->flags;
3347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3348                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3349                         if (_ptr_server_name) {
3350                                 NDR_PULL_ALLOC(ndr, r->server_name);
3351                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3352                         } else {
3353                                 r->server_name = NULL;
3354                         }
3355                         ndr->flags = _flags_save_string;
3356                 }
3357                 {
3358                         uint32_t _flags_save_string = ndr->flags;
3359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3360                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3361                         if (_ptr_user_name) {
3362                                 NDR_PULL_ALLOC(ndr, r->user_name);
3363                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3364                         } else {
3365                                 r->user_name = NULL;
3366                         }
3367                         ndr->flags = _flags_save_string;
3368                 }
3369                 {
3370                         uint32_t _flags_save_string = ndr->flags;
3371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3372                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3373                         if (_ptr_document_name) {
3374                                 NDR_PULL_ALLOC(ndr, r->document_name);
3375                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3376                         } else {
3377                                 r->document_name = NULL;
3378                         }
3379                         ndr->flags = _flags_save_string;
3380                 }
3381                 {
3382                         uint32_t _flags_save_string = ndr->flags;
3383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3384                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3385                         if (_ptr_data_type) {
3386                                 NDR_PULL_ALLOC(ndr, r->data_type);
3387                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3388                         } else {
3389                                 r->data_type = NULL;
3390                         }
3391                         ndr->flags = _flags_save_string;
3392                 }
3393                 {
3394                         uint32_t _flags_save_string = ndr->flags;
3395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3396                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3397                         if (_ptr_text_status) {
3398                                 NDR_PULL_ALLOC(ndr, r->text_status);
3399                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3400                         } else {
3401                                 r->text_status = NULL;
3402                         }
3403                         ndr->flags = _flags_save_string;
3404                 }
3405                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3407                 if (r->priority > 99) {
3408                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3409                 }
3410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3413                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3414                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3415         }
3416         if (ndr_flags & NDR_BUFFERS) {
3417                 {
3418                         uint32_t _flags_save_string = ndr->flags;
3419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3420                         if (r->printer_name) {
3421                                 uint32_t _relative_save_offset;
3422                                 _relative_save_offset = ndr->offset;
3423                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3424                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3425                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3426                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3427                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3428                                 if (ndr->offset > ndr->relative_highest_offset) {
3429                                         ndr->relative_highest_offset = ndr->offset;
3430                                 }
3431                                 ndr->offset = _relative_save_offset;
3432                         }
3433                         ndr->flags = _flags_save_string;
3434                 }
3435                 {
3436                         uint32_t _flags_save_string = ndr->flags;
3437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3438                         if (r->server_name) {
3439                                 uint32_t _relative_save_offset;
3440                                 _relative_save_offset = ndr->offset;
3441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3442                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3443                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3446                                 if (ndr->offset > ndr->relative_highest_offset) {
3447                                         ndr->relative_highest_offset = ndr->offset;
3448                                 }
3449                                 ndr->offset = _relative_save_offset;
3450                         }
3451                         ndr->flags = _flags_save_string;
3452                 }
3453                 {
3454                         uint32_t _flags_save_string = ndr->flags;
3455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3456                         if (r->user_name) {
3457                                 uint32_t _relative_save_offset;
3458                                 _relative_save_offset = ndr->offset;
3459                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3460                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3461                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3462                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3463                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3464                                 if (ndr->offset > ndr->relative_highest_offset) {
3465                                         ndr->relative_highest_offset = ndr->offset;
3466                                 }
3467                                 ndr->offset = _relative_save_offset;
3468                         }
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                         if (r->document_name) {
3475                                 uint32_t _relative_save_offset;
3476                                 _relative_save_offset = ndr->offset;
3477                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3478                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3479                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3480                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3481                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3482                                 if (ndr->offset > ndr->relative_highest_offset) {
3483                                         ndr->relative_highest_offset = ndr->offset;
3484                                 }
3485                                 ndr->offset = _relative_save_offset;
3486                         }
3487                         ndr->flags = _flags_save_string;
3488                 }
3489                 {
3490                         uint32_t _flags_save_string = ndr->flags;
3491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3492                         if (r->data_type) {
3493                                 uint32_t _relative_save_offset;
3494                                 _relative_save_offset = ndr->offset;
3495                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3496                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3497                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3498                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3499                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3500                                 if (ndr->offset > ndr->relative_highest_offset) {
3501                                         ndr->relative_highest_offset = ndr->offset;
3502                                 }
3503                                 ndr->offset = _relative_save_offset;
3504                         }
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                         if (r->text_status) {
3511                                 uint32_t _relative_save_offset;
3512                                 _relative_save_offset = ndr->offset;
3513                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3514                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3515                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3516                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3517                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3518                                 if (ndr->offset > ndr->relative_highest_offset) {
3519                                         ndr->relative_highest_offset = ndr->offset;
3520                                 }
3521                                 ndr->offset = _relative_save_offset;
3522                         }
3523                         ndr->flags = _flags_save_string;
3524                 }
3525         }
3526         return NDR_ERR_SUCCESS;
3527 }
3528
3529 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3530 {
3531         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3532         ndr->depth++;
3533         ndr_print_uint32(ndr, "job_id", r->job_id);
3534         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3535         ndr->depth++;
3536         if (r->printer_name) {
3537                 ndr_print_string(ndr, "printer_name", r->printer_name);
3538         }
3539         ndr->depth--;
3540         ndr_print_ptr(ndr, "server_name", r->server_name);
3541         ndr->depth++;
3542         if (r->server_name) {
3543                 ndr_print_string(ndr, "server_name", r->server_name);
3544         }
3545         ndr->depth--;
3546         ndr_print_ptr(ndr, "user_name", r->user_name);
3547         ndr->depth++;
3548         if (r->user_name) {
3549                 ndr_print_string(ndr, "user_name", r->user_name);
3550         }
3551         ndr->depth--;
3552         ndr_print_ptr(ndr, "document_name", r->document_name);
3553         ndr->depth++;
3554         if (r->document_name) {
3555                 ndr_print_string(ndr, "document_name", r->document_name);
3556         }
3557         ndr->depth--;
3558         ndr_print_ptr(ndr, "data_type", r->data_type);
3559         ndr->depth++;
3560         if (r->data_type) {
3561                 ndr_print_string(ndr, "data_type", r->data_type);
3562         }
3563         ndr->depth--;
3564         ndr_print_ptr(ndr, "text_status", r->text_status);
3565         ndr->depth++;
3566         if (r->text_status) {
3567                 ndr_print_string(ndr, "text_status", r->text_status);
3568         }
3569         ndr->depth--;
3570         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3571         ndr_print_uint32(ndr, "priority", r->priority);
3572         ndr_print_uint32(ndr, "position", r->position);
3573         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3574         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3575         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3576         ndr->depth--;
3577 }
3578
3579 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3580 {
3581         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3582 }
3583
3584 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3585 {
3586         if (ndr_flags & NDR_SCALARS) {
3587                 NDR_CHECK(ndr_push_align(ndr, 5));
3588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3589                 {
3590                         uint32_t _flags_save_string = ndr->flags;
3591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3592                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3593                         ndr->flags = _flags_save_string;
3594                 }
3595                 {
3596                         uint32_t _flags_save_string = ndr->flags;
3597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3598                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3599                         ndr->flags = _flags_save_string;
3600                 }
3601                 {
3602                         uint32_t _flags_save_string = ndr->flags;
3603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3604                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3605                         ndr->flags = _flags_save_string;
3606                 }
3607                 {
3608                         uint32_t _flags_save_string = ndr->flags;
3609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3610                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3611                         ndr->flags = _flags_save_string;
3612                 }
3613                 {
3614                         uint32_t _flags_save_string = ndr->flags;
3615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3617                         ndr->flags = _flags_save_string;
3618                 }
3619                 {
3620                         uint32_t _flags_save_string = ndr->flags;
3621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3622                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3623                         ndr->flags = _flags_save_string;
3624                 }
3625                 {
3626                         uint32_t _flags_save_string = ndr->flags;
3627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3628                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3629                         ndr->flags = _flags_save_string;
3630                 }
3631                 {
3632                         uint32_t _flags_save_string = ndr->flags;
3633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3634                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3635                         ndr->flags = _flags_save_string;
3636                 }
3637                 {
3638                         uint32_t _flags_save_string = ndr->flags;
3639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3640                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3641                         ndr->flags = _flags_save_string;
3642                 }
3643                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3644                 {
3645                         uint32_t _flags_save_string = ndr->flags;
3646                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3647                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3648                         ndr->flags = _flags_save_string;
3649                 }
3650                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3651                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3658                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3661                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3662         }
3663         if (ndr_flags & NDR_BUFFERS) {
3664                 {
3665                         uint32_t _flags_save_string = ndr->flags;
3666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3667                         if (r->printer_name) {
3668                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3669                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3670                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3671                         }
3672                         ndr->flags = _flags_save_string;
3673                 }
3674                 {
3675                         uint32_t _flags_save_string = ndr->flags;
3676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3677                         if (r->server_name) {
3678                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3679                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3680                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3681                         }
3682                         ndr->flags = _flags_save_string;
3683                 }
3684                 {
3685                         uint32_t _flags_save_string = ndr->flags;
3686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3687                         if (r->user_name) {
3688                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3689                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3690                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3691                         }
3692                         ndr->flags = _flags_save_string;
3693                 }
3694                 {
3695                         uint32_t _flags_save_string = ndr->flags;
3696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3697                         if (r->document_name) {
3698                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3699                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3700                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3701                         }
3702                         ndr->flags = _flags_save_string;
3703                 }
3704                 {
3705                         uint32_t _flags_save_string = ndr->flags;
3706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3707                         if (r->notify_name) {
3708                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3710                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3711                         }
3712                         ndr->flags = _flags_save_string;
3713                 }
3714                 {
3715                         uint32_t _flags_save_string = ndr->flags;
3716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3717                         if (r->data_type) {
3718                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3719                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3720                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3721                         }
3722                         ndr->flags = _flags_save_string;
3723                 }
3724                 {
3725                         uint32_t _flags_save_string = ndr->flags;
3726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3727                         if (r->print_processor) {
3728                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3730                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3731                         }
3732                         ndr->flags = _flags_save_string;
3733                 }
3734                 {
3735                         uint32_t _flags_save_string = ndr->flags;
3736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3737                         if (r->parameters) {
3738                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3739                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3740                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3741                         }
3742                         ndr->flags = _flags_save_string;
3743                 }
3744                 {
3745                         uint32_t _flags_save_string = ndr->flags;
3746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3747                         if (r->driver_name) {
3748                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
3749                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3750                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
3751                         }
3752                         ndr->flags = _flags_save_string;
3753                 }
3754                 if (r->devmode) {
3755                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
3756                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3757                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
3758                 }
3759                 {
3760                         uint32_t _flags_save_string = ndr->flags;
3761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3762                         if (r->text_status) {
3763                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3764                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3765                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3766                         }
3767                         ndr->flags = _flags_save_string;
3768                 }
3769                 if (r->secdesc) {
3770                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
3771                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3772                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
3773                 }
3774         }
3775         return NDR_ERR_SUCCESS;
3776 }
3777
3778 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3779 {
3780         uint32_t _ptr_printer_name;
3781         TALLOC_CTX *_mem_save_printer_name_0;
3782         uint32_t _ptr_server_name;
3783         TALLOC_CTX *_mem_save_server_name_0;
3784         uint32_t _ptr_user_name;
3785         TALLOC_CTX *_mem_save_user_name_0;
3786         uint32_t _ptr_document_name;
3787         TALLOC_CTX *_mem_save_document_name_0;
3788         uint32_t _ptr_notify_name;
3789         TALLOC_CTX *_mem_save_notify_name_0;
3790         uint32_t _ptr_data_type;
3791         TALLOC_CTX *_mem_save_data_type_0;
3792         uint32_t _ptr_print_processor;
3793         TALLOC_CTX *_mem_save_print_processor_0;
3794         uint32_t _ptr_parameters;
3795         TALLOC_CTX *_mem_save_parameters_0;
3796         uint32_t _ptr_driver_name;
3797         TALLOC_CTX *_mem_save_driver_name_0;
3798         uint32_t _ptr_devmode;
3799         TALLOC_CTX *_mem_save_devmode_0;
3800         uint32_t _ptr_text_status;
3801         TALLOC_CTX *_mem_save_text_status_0;
3802         uint32_t _ptr_secdesc;
3803         TALLOC_CTX *_mem_save_secdesc_0;
3804         if (ndr_flags & NDR_SCALARS) {
3805                 NDR_CHECK(ndr_pull_align(ndr, 5));
3806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3807                 {
3808                         uint32_t _flags_save_string = ndr->flags;
3809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3811                         if (_ptr_printer_name) {
3812                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3814                         } else {
3815                                 r->printer_name = NULL;
3816                         }
3817                         ndr->flags = _flags_save_string;
3818                 }
3819                 {
3820                         uint32_t _flags_save_string = ndr->flags;
3821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3822                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3823                         if (_ptr_server_name) {
3824                                 NDR_PULL_ALLOC(ndr, r->server_name);
3825                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3826                         } else {
3827                                 r->server_name = NULL;
3828                         }
3829                         ndr->flags = _flags_save_string;
3830                 }
3831                 {
3832                         uint32_t _flags_save_string = ndr->flags;
3833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3834                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3835                         if (_ptr_user_name) {
3836                                 NDR_PULL_ALLOC(ndr, r->user_name);
3837                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3838                         } else {
3839                                 r->user_name = NULL;
3840                         }
3841                         ndr->flags = _flags_save_string;
3842                 }
3843                 {
3844                         uint32_t _flags_save_string = ndr->flags;
3845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3847                         if (_ptr_document_name) {
3848                                 NDR_PULL_ALLOC(ndr, r->document_name);
3849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3850                         } else {
3851                                 r->document_name = NULL;
3852                         }
3853                         ndr->flags = _flags_save_string;
3854                 }
3855                 {
3856                         uint32_t _flags_save_string = ndr->flags;
3857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3858                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3859                         if (_ptr_notify_name) {
3860                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3861                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3862                         } else {
3863                                 r->notify_name = NULL;
3864                         }
3865                         ndr->flags = _flags_save_string;
3866                 }
3867                 {
3868                         uint32_t _flags_save_string = ndr->flags;
3869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3870                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3871                         if (_ptr_data_type) {
3872                                 NDR_PULL_ALLOC(ndr, r->data_type);
3873                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3874                         } else {
3875                                 r->data_type = NULL;
3876                         }
3877                         ndr->flags = _flags_save_string;
3878                 }
3879                 {
3880                         uint32_t _flags_save_string = ndr->flags;
3881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3883                         if (_ptr_print_processor) {
3884                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3886                         } else {
3887                                 r->print_processor = NULL;
3888                         }
3889                         ndr->flags = _flags_save_string;
3890                 }
3891                 {
3892                         uint32_t _flags_save_string = ndr->flags;
3893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3894                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3895                         if (_ptr_parameters) {
3896                                 NDR_PULL_ALLOC(ndr, r->parameters);
3897                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3898                         } else {
3899                                 r->parameters = NULL;
3900                         }
3901                         ndr->flags = _flags_save_string;
3902                 }
3903                 {
3904                         uint32_t _flags_save_string = ndr->flags;
3905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3906                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3907                         if (_ptr_driver_name) {
3908                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3909                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3910                         } else {
3911                                 r->driver_name = NULL;
3912                         }
3913                         ndr->flags = _flags_save_string;
3914                 }
3915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3916                 if (_ptr_devmode) {
3917                         NDR_PULL_ALLOC(ndr, r->devmode);
3918                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3919                 } else {
3920                         r->devmode = NULL;
3921                 }
3922                 {
3923                         uint32_t _flags_save_string = ndr->flags;
3924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3925                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3926                         if (_ptr_text_status) {
3927                                 NDR_PULL_ALLOC(ndr, r->text_status);
3928                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3929                         } else {
3930                                 r->text_status = NULL;
3931                         }
3932                         ndr->flags = _flags_save_string;
3933                 }
3934                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3935                 if (_ptr_secdesc) {
3936                         NDR_PULL_ALLOC(ndr, r->secdesc);
3937                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3938                 } else {
3939                         r->secdesc = NULL;
3940                 }
3941                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3943                 if (r->priority > 99) {
3944                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3945                 }
3946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3951                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3954                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3955         }
3956         if (ndr_flags & NDR_BUFFERS) {
3957                 {
3958                         uint32_t _flags_save_string = ndr->flags;
3959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3960                         if (r->printer_name) {
3961                                 uint32_t _relative_save_offset;
3962                                 _relative_save_offset = ndr->offset;
3963                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3964                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3965                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3966                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3967                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3968                                 if (ndr->offset > ndr->relative_highest_offset) {
3969                                         ndr->relative_highest_offset = ndr->offset;
3970                                 }
3971                                 ndr->offset = _relative_save_offset;
3972                         }
3973                         ndr->flags = _flags_save_string;
3974                 }
3975                 {
3976                         uint32_t _flags_save_string = ndr->flags;
3977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3978                         if (r->server_name) {
3979                                 uint32_t _relative_save_offset;
3980                                 _relative_save_offset = ndr->offset;
3981                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3982                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3983                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3984                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3985                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3986                                 if (ndr->offset > ndr->relative_highest_offset) {
3987                                         ndr->relative_highest_offset = ndr->offset;
3988                                 }
3989                                 ndr->offset = _relative_save_offset;
3990                         }
3991                         ndr->flags = _flags_save_string;
3992                 }
3993                 {
3994                         uint32_t _flags_save_string = ndr->flags;
3995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3996                         if (r->user_name) {
3997                                 uint32_t _relative_save_offset;
3998                                 _relative_save_offset = ndr->offset;
3999                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4000                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4001                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4002                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4003                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4004                                 if (ndr->offset > ndr->relative_highest_offset) {
4005                                         ndr->relative_highest_offset = ndr->offset;
4006                                 }
4007                                 ndr->offset = _relative_save_offset;
4008                         }
4009                         ndr->flags = _flags_save_string;
4010                 }
4011                 {
4012                         uint32_t _flags_save_string = ndr->flags;
4013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4014                         if (r->document_name) {
4015                                 uint32_t _relative_save_offset;
4016                                 _relative_save_offset = ndr->offset;
4017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4018                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4019                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4020                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4022                                 if (ndr->offset > ndr->relative_highest_offset) {
4023                                         ndr->relative_highest_offset = ndr->offset;
4024                                 }
4025                                 ndr->offset = _relative_save_offset;
4026                         }
4027                         ndr->flags = _flags_save_string;
4028                 }
4029                 {
4030                         uint32_t _flags_save_string = ndr->flags;
4031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4032                         if (r->notify_name) {
4033                                 uint32_t _relative_save_offset;
4034                                 _relative_save_offset = ndr->offset;
4035                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4036                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4037                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4038                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4039                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4040                                 if (ndr->offset > ndr->relative_highest_offset) {
4041                                         ndr->relative_highest_offset = ndr->offset;
4042                                 }
4043                                 ndr->offset = _relative_save_offset;
4044                         }
4045                         ndr->flags = _flags_save_string;
4046                 }
4047                 {
4048                         uint32_t _flags_save_string = ndr->flags;
4049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4050                         if (r->data_type) {
4051                                 uint32_t _relative_save_offset;
4052                                 _relative_save_offset = ndr->offset;
4053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4054                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4055                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4058                                 if (ndr->offset > ndr->relative_highest_offset) {
4059                                         ndr->relative_highest_offset = ndr->offset;
4060                                 }
4061                                 ndr->offset = _relative_save_offset;
4062                         }
4063                         ndr->flags = _flags_save_string;
4064                 }
4065                 {
4066                         uint32_t _flags_save_string = ndr->flags;
4067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4068                         if (r->print_processor) {
4069                                 uint32_t _relative_save_offset;
4070                                 _relative_save_offset = ndr->offset;
4071                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4072                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4073                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4074                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4075                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4076                                 if (ndr->offset > ndr->relative_highest_offset) {
4077                                         ndr->relative_highest_offset = ndr->offset;
4078                                 }
4079                                 ndr->offset = _relative_save_offset;
4080                         }
4081                         ndr->flags = _flags_save_string;
4082                 }
4083                 {
4084                         uint32_t _flags_save_string = ndr->flags;
4085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4086                         if (r->parameters) {
4087                                 uint32_t _relative_save_offset;
4088                                 _relative_save_offset = ndr->offset;
4089                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4090                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4091                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4092                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4093                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4094                                 if (ndr->offset > ndr->relative_highest_offset) {
4095                                         ndr->relative_highest_offset = ndr->offset;
4096                                 }
4097                                 ndr->offset = _relative_save_offset;
4098                         }
4099                         ndr->flags = _flags_save_string;
4100                 }
4101                 {
4102                         uint32_t _flags_save_string = ndr->flags;
4103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4104                         if (r->driver_name) {
4105                                 uint32_t _relative_save_offset;
4106                                 _relative_save_offset = ndr->offset;
4107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4108                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4109                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4112                                 if (ndr->offset > ndr->relative_highest_offset) {
4113                                         ndr->relative_highest_offset = ndr->offset;
4114                                 }
4115                                 ndr->offset = _relative_save_offset;
4116                         }
4117                         ndr->flags = _flags_save_string;
4118                 }
4119                 if (r->devmode) {
4120                         uint32_t _relative_save_offset;
4121                         _relative_save_offset = ndr->offset;
4122                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4123                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4124                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4125                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4127                         if (ndr->offset > ndr->relative_highest_offset) {
4128                                 ndr->relative_highest_offset = ndr->offset;
4129                         }
4130                         ndr->offset = _relative_save_offset;
4131                 }
4132                 {
4133                         uint32_t _flags_save_string = ndr->flags;
4134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4135                         if (r->text_status) {
4136                                 uint32_t _relative_save_offset;
4137                                 _relative_save_offset = ndr->offset;
4138                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4139                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4140                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4141                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4142                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4143                                 if (ndr->offset > ndr->relative_highest_offset) {
4144                                         ndr->relative_highest_offset = ndr->offset;
4145                                 }
4146                                 ndr->offset = _relative_save_offset;
4147                         }
4148                         ndr->flags = _flags_save_string;
4149                 }
4150                 if (r->secdesc) {
4151                         uint32_t _relative_save_offset;
4152                         _relative_save_offset = ndr->offset;
4153                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4154                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4155                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4156                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4158                         if (ndr->offset > ndr->relative_highest_offset) {
4159                                 ndr->relative_highest_offset = ndr->offset;
4160                         }
4161                         ndr->offset = _relative_save_offset;
4162                 }
4163         }
4164         return NDR_ERR_SUCCESS;
4165 }
4166
4167 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4168 {
4169         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4170         ndr->depth++;
4171         ndr_print_uint32(ndr, "job_id", r->job_id);
4172         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4173         ndr->depth++;
4174         if (r->printer_name) {
4175                 ndr_print_string(ndr, "printer_name", r->printer_name);
4176         }
4177         ndr->depth--;
4178         ndr_print_ptr(ndr, "server_name", r->server_name);
4179         ndr->depth++;
4180         if (r->server_name) {
4181                 ndr_print_string(ndr, "server_name", r->server_name);
4182         }
4183         ndr->depth--;
4184         ndr_print_ptr(ndr, "user_name", r->user_name);
4185         ndr->depth++;
4186         if (r->user_name) {
4187                 ndr_print_string(ndr, "user_name", r->user_name);
4188         }
4189         ndr->depth--;
4190         ndr_print_ptr(ndr, "document_name", r->document_name);
4191         ndr->depth++;
4192         if (r->document_name) {
4193                 ndr_print_string(ndr, "document_name", r->document_name);
4194         }
4195         ndr->depth--;
4196         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4197         ndr->depth++;
4198         if (r->notify_name) {
4199                 ndr_print_string(ndr, "notify_name", r->notify_name);
4200         }
4201         ndr->depth--;
4202         ndr_print_ptr(ndr, "data_type", r->data_type);
4203         ndr->depth++;
4204         if (r->data_type) {
4205                 ndr_print_string(ndr, "data_type", r->data_type);
4206         }
4207         ndr->depth--;
4208         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4209         ndr->depth++;
4210         if (r->print_processor) {
4211                 ndr_print_string(ndr, "print_processor", r->print_processor);
4212         }
4213         ndr->depth--;
4214         ndr_print_ptr(ndr, "parameters", r->parameters);
4215         ndr->depth++;
4216         if (r->parameters) {
4217                 ndr_print_string(ndr, "parameters", r->parameters);
4218         }
4219         ndr->depth--;
4220         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4221         ndr->depth++;
4222         if (r->driver_name) {
4223                 ndr_print_string(ndr, "driver_name", r->driver_name);
4224         }
4225         ndr->depth--;
4226         ndr_print_ptr(ndr, "devmode", r->devmode);
4227         ndr->depth++;
4228         if (r->devmode) {
4229                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4230         }
4231         ndr->depth--;
4232         ndr_print_ptr(ndr, "text_status", r->text_status);
4233         ndr->depth++;
4234         if (r->text_status) {
4235                 ndr_print_string(ndr, "text_status", r->text_status);
4236         }
4237         ndr->depth--;
4238         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4239         ndr->depth++;
4240         if (r->secdesc) {
4241                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4242         }
4243         ndr->depth--;
4244         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4245         ndr_print_uint32(ndr, "priority", r->priority);
4246         ndr_print_uint32(ndr, "position", r->position);
4247         ndr_print_uint32(ndr, "start_time", r->start_time);
4248         ndr_print_uint32(ndr, "until_time", r->until_time);
4249         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4250         ndr_print_uint32(ndr, "size", r->size);
4251         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4252         ndr_print_uint32(ndr, "time", r->time);
4253         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4254         ndr->depth--;
4255 }
4256
4257 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4258 {
4259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4260 }
4261
4262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4263 {
4264         if (ndr_flags & NDR_SCALARS) {
4265                 NDR_CHECK(ndr_push_align(ndr, 4));
4266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4269                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4270         }
4271         if (ndr_flags & NDR_BUFFERS) {
4272         }
4273         return NDR_ERR_SUCCESS;
4274 }
4275
4276 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4277 {
4278         if (ndr_flags & NDR_SCALARS) {
4279                 NDR_CHECK(ndr_pull_align(ndr, 4));
4280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4283                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4284         }
4285         if (ndr_flags & NDR_BUFFERS) {
4286         }
4287         return NDR_ERR_SUCCESS;
4288 }
4289
4290 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4291 {
4292         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4293         ndr->depth++;
4294         ndr_print_uint32(ndr, "job_id", r->job_id);
4295         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4296         ndr_print_uint32(ndr, "reserved", r->reserved);
4297         ndr->depth--;
4298 }
4299
4300 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4301 {
4302         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4303 }
4304
4305 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4306 {
4307         if (ndr_flags & NDR_SCALARS) {
4308                 NDR_CHECK(ndr_push_align(ndr, 5));
4309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4310                 {
4311                         uint32_t _flags_save_string = ndr->flags;
4312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4313                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4314                         ndr->flags = _flags_save_string;
4315                 }
4316                 {
4317                         uint32_t _flags_save_string = ndr->flags;
4318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4319                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4320                         ndr->flags = _flags_save_string;
4321                 }
4322                 {
4323                         uint32_t _flags_save_string = ndr->flags;
4324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4325                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4326                         ndr->flags = _flags_save_string;
4327                 }
4328                 {
4329                         uint32_t _flags_save_string = ndr->flags;
4330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4331                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4332                         ndr->flags = _flags_save_string;
4333                 }
4334                 {
4335                         uint32_t _flags_save_string = ndr->flags;
4336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4337                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4338                         ndr->flags = _flags_save_string;
4339                 }
4340                 {
4341                         uint32_t _flags_save_string = ndr->flags;
4342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4343                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4344                         ndr->flags = _flags_save_string;
4345                 }
4346                 {
4347                         uint32_t _flags_save_string = ndr->flags;
4348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4349                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4350                         ndr->flags = _flags_save_string;
4351                 }
4352                 {
4353                         uint32_t _flags_save_string = ndr->flags;
4354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4355                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4356                         ndr->flags = _flags_save_string;
4357                 }
4358                 {
4359                         uint32_t _flags_save_string = ndr->flags;
4360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4361                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4362                         ndr->flags = _flags_save_string;
4363                 }
4364                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4365                 {
4366                         uint32_t _flags_save_string = ndr->flags;
4367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4368                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4369                         ndr->flags = _flags_save_string;
4370                 }
4371                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4372                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4379                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4383                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4384         }
4385         if (ndr_flags & NDR_BUFFERS) {
4386                 {
4387                         uint32_t _flags_save_string = ndr->flags;
4388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4389                         if (r->printer_name) {
4390                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
4391                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4392                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
4393                         }
4394                         ndr->flags = _flags_save_string;
4395                 }
4396                 {
4397                         uint32_t _flags_save_string = ndr->flags;
4398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4399                         if (r->server_name) {
4400                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
4401                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4402                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
4403                         }
4404                         ndr->flags = _flags_save_string;
4405                 }
4406                 {
4407                         uint32_t _flags_save_string = ndr->flags;
4408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4409                         if (r->user_name) {
4410                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
4411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4412                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
4413                         }
4414                         ndr->flags = _flags_save_string;
4415                 }
4416                 {
4417                         uint32_t _flags_save_string = ndr->flags;
4418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4419                         if (r->document_name) {
4420                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
4421                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4422                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
4423                         }
4424                         ndr->flags = _flags_save_string;
4425                 }
4426                 {
4427                         uint32_t _flags_save_string = ndr->flags;
4428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4429                         if (r->notify_name) {
4430                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
4431                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4432                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
4433                         }
4434                         ndr->flags = _flags_save_string;
4435                 }
4436                 {
4437                         uint32_t _flags_save_string = ndr->flags;
4438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4439                         if (r->data_type) {
4440                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
4441                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4442                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
4443                         }
4444                         ndr->flags = _flags_save_string;
4445                 }
4446                 {
4447                         uint32_t _flags_save_string = ndr->flags;
4448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4449                         if (r->print_processor) {
4450                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
4451                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4452                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
4453                         }
4454                         ndr->flags = _flags_save_string;
4455                 }
4456                 {
4457                         uint32_t _flags_save_string = ndr->flags;
4458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4459                         if (r->parameters) {
4460                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
4461                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4462                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
4463                         }
4464                         ndr->flags = _flags_save_string;
4465                 }
4466                 {
4467                         uint32_t _flags_save_string = ndr->flags;
4468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4469                         if (r->driver_name) {
4470                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
4471                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4472                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
4473                         }
4474                         ndr->flags = _flags_save_string;
4475                 }
4476                 if (r->devmode) {
4477                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
4478                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4479                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
4480                 }
4481                 {
4482                         uint32_t _flags_save_string = ndr->flags;
4483                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4484                         if (r->text_status) {
4485                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
4486                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4487                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
4488                         }
4489                         ndr->flags = _flags_save_string;
4490                 }
4491                 if (r->secdesc) {
4492                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
4493                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4494                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
4495                 }
4496         }
4497         return NDR_ERR_SUCCESS;
4498 }
4499
4500 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4501 {
4502         uint32_t _ptr_printer_name;
4503         TALLOC_CTX *_mem_save_printer_name_0;
4504         uint32_t _ptr_server_name;
4505         TALLOC_CTX *_mem_save_server_name_0;
4506         uint32_t _ptr_user_name;
4507         TALLOC_CTX *_mem_save_user_name_0;
4508         uint32_t _ptr_document_name;
4509         TALLOC_CTX *_mem_save_document_name_0;
4510         uint32_t _ptr_notify_name;
4511         TALLOC_CTX *_mem_save_notify_name_0;
4512         uint32_t _ptr_data_type;
4513         TALLOC_CTX *_mem_save_data_type_0;
4514         uint32_t _ptr_print_processor;
4515         TALLOC_CTX *_mem_save_print_processor_0;
4516         uint32_t _ptr_parameters;
4517         TALLOC_CTX *_mem_save_parameters_0;
4518         uint32_t _ptr_driver_name;
4519         TALLOC_CTX *_mem_save_driver_name_0;
4520         uint32_t _ptr_devmode;
4521         TALLOC_CTX *_mem_save_devmode_0;
4522         uint32_t _ptr_text_status;
4523         TALLOC_CTX *_mem_save_text_status_0;
4524         uint32_t _ptr_secdesc;
4525         TALLOC_CTX *_mem_save_secdesc_0;
4526         if (ndr_flags & NDR_SCALARS) {
4527                 NDR_CHECK(ndr_pull_align(ndr, 5));
4528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4529                 {
4530                         uint32_t _flags_save_string = ndr->flags;
4531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4532                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4533                         if (_ptr_printer_name) {
4534                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4535                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4536                         } else {
4537                                 r->printer_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4545                         if (_ptr_server_name) {
4546                                 NDR_PULL_ALLOC(ndr, r->server_name);
4547                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4548                         } else {
4549                                 r->server_name = NULL;
4550                         }
4551                         ndr->flags = _flags_save_string;
4552                 }
4553                 {
4554                         uint32_t _flags_save_string = ndr->flags;
4555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4556                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4557                         if (_ptr_user_name) {
4558                                 NDR_PULL_ALLOC(ndr, r->user_name);
4559                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4560                         } else {
4561                                 r->user_name = NULL;
4562                         }
4563                         ndr->flags = _flags_save_string;
4564                 }
4565                 {
4566                         uint32_t _flags_save_string = ndr->flags;
4567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4568                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4569                         if (_ptr_document_name) {
4570                                 NDR_PULL_ALLOC(ndr, r->document_name);
4571                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4572                         } else {
4573                                 r->document_name = NULL;
4574                         }
4575                         ndr->flags = _flags_save_string;
4576                 }
4577                 {
4578                         uint32_t _flags_save_string = ndr->flags;
4579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4580                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4581                         if (_ptr_notify_name) {
4582                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4583                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4584                         } else {
4585                                 r->notify_name = NULL;
4586                         }
4587                         ndr->flags = _flags_save_string;
4588                 }
4589                 {
4590                         uint32_t _flags_save_string = ndr->flags;
4591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4592                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4593                         if (_ptr_data_type) {
4594                                 NDR_PULL_ALLOC(ndr, r->data_type);
4595                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4596                         } else {
4597                                 r->data_type = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4605                         if (_ptr_print_processor) {
4606                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4607                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4608                         } else {
4609                                 r->print_processor = NULL;
4610                         }
4611                         ndr->flags = _flags_save_string;
4612                 }
4613                 {
4614                         uint32_t _flags_save_string = ndr->flags;
4615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4616                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4617                         if (_ptr_parameters) {
4618                                 NDR_PULL_ALLOC(ndr, r->parameters);
4619                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4620                         } else {
4621                                 r->parameters = NULL;
4622                         }
4623                         ndr->flags = _flags_save_string;
4624                 }
4625                 {
4626                         uint32_t _flags_save_string = ndr->flags;
4627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4628                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4629                         if (_ptr_driver_name) {
4630                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4631                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4632                         } else {
4633                                 r->driver_name = NULL;
4634                         }
4635                         ndr->flags = _flags_save_string;
4636                 }
4637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4638                 if (_ptr_devmode) {
4639                         NDR_PULL_ALLOC(ndr, r->devmode);
4640                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4641                 } else {
4642                         r->devmode = NULL;
4643                 }
4644                 {
4645                         uint32_t _flags_save_string = ndr->flags;
4646                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4647                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4648                         if (_ptr_text_status) {
4649                                 NDR_PULL_ALLOC(ndr, r->text_status);
4650                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4651                         } else {
4652                                 r->text_status = NULL;
4653                         }
4654                         ndr->flags = _flags_save_string;
4655                 }
4656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4657                 if (_ptr_secdesc) {
4658                         NDR_PULL_ALLOC(ndr, r->secdesc);
4659                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4660                 } else {
4661                         r->secdesc = NULL;
4662                 }
4663                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4665                 if (r->priority > 99) {
4666                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4667                 }
4668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4673                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4677                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4678         }
4679         if (ndr_flags & NDR_BUFFERS) {
4680                 {
4681                         uint32_t _flags_save_string = ndr->flags;
4682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4683                         if (r->printer_name) {
4684                                 uint32_t _relative_save_offset;
4685                                 _relative_save_offset = ndr->offset;
4686                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4687                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4688                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4689                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4690                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4691                                 if (ndr->offset > ndr->relative_highest_offset) {
4692                                         ndr->relative_highest_offset = ndr->offset;
4693                                 }
4694                                 ndr->offset = _relative_save_offset;
4695                         }
4696                         ndr->flags = _flags_save_string;
4697                 }
4698                 {
4699                         uint32_t _flags_save_string = ndr->flags;
4700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4701                         if (r->server_name) {
4702                                 uint32_t _relative_save_offset;
4703                                 _relative_save_offset = ndr->offset;
4704                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4705                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4706                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4707                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4708                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4709                                 if (ndr->offset > ndr->relative_highest_offset) {
4710                                         ndr->relative_highest_offset = ndr->offset;
4711                                 }
4712                                 ndr->offset = _relative_save_offset;
4713                         }
4714                         ndr->flags = _flags_save_string;
4715                 }
4716                 {
4717                         uint32_t _flags_save_string = ndr->flags;
4718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4719                         if (r->user_name) {
4720                                 uint32_t _relative_save_offset;
4721                                 _relative_save_offset = ndr->offset;
4722                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4723                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4724                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4725                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4726                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4727                                 if (ndr->offset > ndr->relative_highest_offset) {
4728                                         ndr->relative_highest_offset = ndr->offset;
4729                                 }
4730                                 ndr->offset = _relative_save_offset;
4731                         }
4732                         ndr->flags = _flags_save_string;
4733                 }
4734                 {
4735                         uint32_t _flags_save_string = ndr->flags;
4736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4737                         if (r->document_name) {
4738                                 uint32_t _relative_save_offset;
4739                                 _relative_save_offset = ndr->offset;
4740                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4741                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4742                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4743                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4744                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4745                                 if (ndr->offset > ndr->relative_highest_offset) {
4746                                         ndr->relative_highest_offset = ndr->offset;
4747                                 }
4748                                 ndr->offset = _relative_save_offset;
4749                         }
4750                         ndr->flags = _flags_save_string;
4751                 }
4752                 {
4753                         uint32_t _flags_save_string = ndr->flags;
4754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4755                         if (r->notify_name) {
4756                                 uint32_t _relative_save_offset;
4757                                 _relative_save_offset = ndr->offset;
4758                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4759                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4760                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4761                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4762                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4763                                 if (ndr->offset > ndr->relative_highest_offset) {
4764                                         ndr->relative_highest_offset = ndr->offset;
4765                                 }
4766                                 ndr->offset = _relative_save_offset;
4767                         }
4768                         ndr->flags = _flags_save_string;
4769                 }
4770                 {
4771                         uint32_t _flags_save_string = ndr->flags;
4772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4773                         if (r->data_type) {
4774                                 uint32_t _relative_save_offset;
4775                                 _relative_save_offset = ndr->offset;
4776                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4777                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4778                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4779                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4780                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4781                                 if (ndr->offset > ndr->relative_highest_offset) {
4782                                         ndr->relative_highest_offset = ndr->offset;
4783                                 }
4784                                 ndr->offset = _relative_save_offset;
4785                         }
4786                         ndr->flags = _flags_save_string;
4787                 }
4788                 {
4789                         uint32_t _flags_save_string = ndr->flags;
4790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4791                         if (r->print_processor) {
4792                                 uint32_t _relative_save_offset;
4793                                 _relative_save_offset = ndr->offset;
4794                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4795                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4796                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4797                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4798                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4799                                 if (ndr->offset > ndr->relative_highest_offset) {
4800                                         ndr->relative_highest_offset = ndr->offset;
4801                                 }
4802                                 ndr->offset = _relative_save_offset;
4803                         }
4804                         ndr->flags = _flags_save_string;
4805                 }
4806                 {
4807                         uint32_t _flags_save_string = ndr->flags;
4808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4809                         if (r->parameters) {
4810                                 uint32_t _relative_save_offset;
4811                                 _relative_save_offset = ndr->offset;
4812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4813                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4814                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4817                                 if (ndr->offset > ndr->relative_highest_offset) {
4818                                         ndr->relative_highest_offset = ndr->offset;
4819                                 }
4820                                 ndr->offset = _relative_save_offset;
4821                         }
4822                         ndr->flags = _flags_save_string;
4823                 }
4824                 {
4825                         uint32_t _flags_save_string = ndr->flags;
4826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4827                         if (r->driver_name) {
4828                                 uint32_t _relative_save_offset;
4829                                 _relative_save_offset = ndr->offset;
4830                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4831                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4832                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4833                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4834                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4835                                 if (ndr->offset > ndr->relative_highest_offset) {
4836                                         ndr->relative_highest_offset = ndr->offset;
4837                                 }
4838                                 ndr->offset = _relative_save_offset;
4839                         }
4840                         ndr->flags = _flags_save_string;
4841                 }
4842                 if (r->devmode) {
4843                         uint32_t _relative_save_offset;
4844                         _relative_save_offset = ndr->offset;
4845                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4846                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4847                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4848                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4850                         if (ndr->offset > ndr->relative_highest_offset) {
4851                                 ndr->relative_highest_offset = ndr->offset;
4852                         }
4853                         ndr->offset = _relative_save_offset;
4854                 }
4855                 {
4856                         uint32_t _flags_save_string = ndr->flags;
4857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4858                         if (r->text_status) {
4859                                 uint32_t _relative_save_offset;
4860                                 _relative_save_offset = ndr->offset;
4861                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4862                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4863                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4864                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4865                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4866                                 if (ndr->offset > ndr->relative_highest_offset) {
4867                                         ndr->relative_highest_offset = ndr->offset;
4868                                 }
4869                                 ndr->offset = _relative_save_offset;
4870                         }
4871                         ndr->flags = _flags_save_string;
4872                 }
4873                 if (r->secdesc) {
4874                         uint32_t _relative_save_offset;
4875                         _relative_save_offset = ndr->offset;
4876                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4877                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4878                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4879                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4881                         if (ndr->offset > ndr->relative_highest_offset) {
4882                                 ndr->relative_highest_offset = ndr->offset;
4883                         }
4884                         ndr->offset = _relative_save_offset;
4885                 }
4886         }
4887         return NDR_ERR_SUCCESS;
4888 }
4889
4890 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4891 {
4892         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4893         ndr->depth++;
4894         ndr_print_uint32(ndr, "job_id", r->job_id);
4895         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4896         ndr->depth++;
4897         if (r->printer_name) {
4898                 ndr_print_string(ndr, "printer_name", r->printer_name);
4899         }
4900         ndr->depth--;
4901         ndr_print_ptr(ndr, "server_name", r->server_name);
4902         ndr->depth++;
4903         if (r->server_name) {
4904                 ndr_print_string(ndr, "server_name", r->server_name);
4905         }
4906         ndr->depth--;
4907         ndr_print_ptr(ndr, "user_name", r->user_name);
4908         ndr->depth++;
4909         if (r->user_name) {
4910                 ndr_print_string(ndr, "user_name", r->user_name);
4911         }
4912         ndr->depth--;
4913         ndr_print_ptr(ndr, "document_name", r->document_name);
4914         ndr->depth++;
4915         if (r->document_name) {
4916                 ndr_print_string(ndr, "document_name", r->document_name);
4917         }
4918         ndr->depth--;
4919         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4920         ndr->depth++;
4921         if (r->notify_name) {
4922                 ndr_print_string(ndr, "notify_name", r->notify_name);
4923         }
4924         ndr->depth--;
4925         ndr_print_ptr(ndr, "data_type", r->data_type);
4926         ndr->depth++;
4927         if (r->data_type) {
4928                 ndr_print_string(ndr, "data_type", r->data_type);
4929         }
4930         ndr->depth--;
4931         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4932         ndr->depth++;
4933         if (r->print_processor) {
4934                 ndr_print_string(ndr, "print_processor", r->print_processor);
4935         }
4936         ndr->depth--;
4937         ndr_print_ptr(ndr, "parameters", r->parameters);
4938         ndr->depth++;
4939         if (r->parameters) {
4940                 ndr_print_string(ndr, "parameters", r->parameters);
4941         }
4942         ndr->depth--;
4943         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4944         ndr->depth++;
4945         if (r->driver_name) {
4946                 ndr_print_string(ndr, "driver_name", r->driver_name);
4947         }
4948         ndr->depth--;
4949         ndr_print_ptr(ndr, "devmode", r->devmode);
4950         ndr->depth++;
4951         if (r->devmode) {
4952                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4953         }
4954         ndr->depth--;
4955         ndr_print_ptr(ndr, "text_status", r->text_status);
4956         ndr->depth++;
4957         if (r->text_status) {
4958                 ndr_print_string(ndr, "text_status", r->text_status);
4959         }
4960         ndr->depth--;
4961         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4962         ndr->depth++;
4963         if (r->secdesc) {
4964                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4965         }
4966         ndr->depth--;
4967         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4968         ndr_print_uint32(ndr, "priority", r->priority);
4969         ndr_print_uint32(ndr, "position", r->position);
4970         ndr_print_uint32(ndr, "start_time", r->start_time);
4971         ndr_print_uint32(ndr, "until_time", r->until_time);
4972         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4973         ndr_print_uint32(ndr, "size", r->size);
4974         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4975         ndr_print_uint32(ndr, "time", r->time);
4976         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4977         ndr_print_uint32(ndr, "size_high", r->size_high);
4978         ndr->depth--;
4979 }
4980
4981 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4982 {
4983         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4984 }
4985
4986 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4987 {
4988         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4989         if (ndr_flags & NDR_SCALARS) {
4990                 int level = ndr_push_get_switch_value(ndr, r);
4991                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4992                 switch (level) {
4993                         case 1: {
4994                                 NDR_CHECK(ndr_push_align(ndr, 5));
4995                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4996                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4997                         break; }
4998
4999                         case 2: {
5000                                 NDR_CHECK(ndr_push_align(ndr, 5));
5001                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5002                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5003                         break; }
5004
5005                         case 3: {
5006                                 NDR_CHECK(ndr_push_align(ndr, 4));
5007                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5008                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5009                         break; }
5010
5011                         case 4: {
5012                                 NDR_CHECK(ndr_push_align(ndr, 5));
5013                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5014                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5015                         break; }
5016
5017                         default: {
5018                         break; }
5019
5020                 }
5021         }
5022         if (ndr_flags & NDR_BUFFERS) {
5023                 int level = ndr_push_get_switch_value(ndr, r);
5024                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
5025                 switch (level) {
5026                         case 1:
5027                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5028                         break;
5029
5030                         case 2:
5031                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5032                         break;
5033
5034                         case 3:
5035                         break;
5036
5037                         case 4:
5038                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5039                         break;
5040
5041                         default:
5042                         break;
5043
5044                 }
5045         }
5046         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
5047         return NDR_ERR_SUCCESS;
5048 }
5049
5050 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
5051 {
5052         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
5053         int level;
5054         level = ndr_pull_get_switch_value(ndr, r);
5055         if (ndr_flags & NDR_SCALARS) {
5056                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5057                 switch (level) {
5058                         case 1: {
5059                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5060                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5061                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5062                         break; }
5063
5064                         case 2: {
5065                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5066                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5067                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5068                         break; }
5069
5070                         case 3: {
5071                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5072                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5073                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5074                         break; }
5075
5076                         case 4: {
5077                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5078                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5079                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5080                         break; }
5081
5082                         default: {
5083                         break; }
5084
5085                 }
5086         }
5087         if (ndr_flags & NDR_BUFFERS) {
5088                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5089                 switch (level) {
5090                         case 1:
5091                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5092                         break;
5093
5094                         case 2:
5095                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5096                         break;
5097
5098                         case 3:
5099                         break;
5100
5101                         case 4:
5102                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5103                         break;
5104
5105                         default:
5106                         break;
5107
5108                 }
5109         }
5110         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5111         return NDR_ERR_SUCCESS;
5112 }
5113
5114 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5115 {
5116         int level;
5117         level = ndr_print_get_switch_value(ndr, r);
5118         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5119         switch (level) {
5120                 case 1:
5121                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5122                 break;
5123
5124                 case 2:
5125                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5126                 break;
5127
5128                 case 3:
5129                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5130                 break;
5131
5132                 case 4:
5133                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5134                 break;
5135
5136                 default:
5137                 break;
5138
5139         }
5140 }
5141
5142 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5143 {
5144         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5145 }
5146
5147 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5148 {
5149         if (ndr_flags & NDR_SCALARS) {
5150                 NDR_CHECK(ndr_push_align(ndr, 5));
5151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5158                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5163                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5164                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5165         }
5166         if (ndr_flags & NDR_BUFFERS) {
5167                 if (r->printer_name) {
5168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5171                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5172                 }
5173                 if (r->server_name) {
5174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5177                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5178                 }
5179                 if (r->user_name) {
5180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5183                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5184                 }
5185                 if (r->document_name) {
5186                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5189                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5190                 }
5191                 if (r->data_type) {
5192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5195                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5196                 }
5197                 if (r->text_status) {
5198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5201                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5202                 }
5203         }
5204         return NDR_ERR_SUCCESS;
5205 }
5206
5207 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5208 {
5209         uint32_t _ptr_printer_name;
5210         TALLOC_CTX *_mem_save_printer_name_0;
5211         uint32_t _ptr_server_name;
5212         TALLOC_CTX *_mem_save_server_name_0;
5213         uint32_t _ptr_user_name;
5214         TALLOC_CTX *_mem_save_user_name_0;
5215         uint32_t _ptr_document_name;
5216         TALLOC_CTX *_mem_save_document_name_0;
5217         uint32_t _ptr_data_type;
5218         TALLOC_CTX *_mem_save_data_type_0;
5219         uint32_t _ptr_text_status;
5220         TALLOC_CTX *_mem_save_text_status_0;
5221         if (ndr_flags & NDR_SCALARS) {
5222                 NDR_CHECK(ndr_pull_align(ndr, 5));
5223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5225                 if (_ptr_printer_name) {
5226                         NDR_PULL_ALLOC(ndr, r->printer_name);
5227                 } else {
5228                         r->printer_name = NULL;
5229                 }
5230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5231                 if (_ptr_server_name) {
5232                         NDR_PULL_ALLOC(ndr, r->server_name);
5233                 } else {
5234                         r->server_name = NULL;
5235                 }
5236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5237                 if (_ptr_user_name) {
5238                         NDR_PULL_ALLOC(ndr, r->user_name);
5239                 } else {
5240                         r->user_name = NULL;
5241                 }
5242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5243                 if (_ptr_document_name) {
5244                         NDR_PULL_ALLOC(ndr, r->document_name);
5245                 } else {
5246                         r->document_name = NULL;
5247                 }
5248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5249                 if (_ptr_data_type) {
5250                         NDR_PULL_ALLOC(ndr, r->data_type);
5251                 } else {
5252                         r->data_type = NULL;
5253                 }
5254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5255                 if (_ptr_text_status) {
5256                         NDR_PULL_ALLOC(ndr, r->text_status);
5257                 } else {
5258                         r->text_status = NULL;
5259                 }
5260                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5262                 if (r->priority > 99) {
5263                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5264                 }
5265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5268                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5269                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5270         }
5271         if (ndr_flags & NDR_BUFFERS) {
5272                 if (r->printer_name) {
5273                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5274                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5276                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5277                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5278                                 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));
5279                         }
5280                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5281                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5283                 }
5284                 if (r->server_name) {
5285                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5286                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5287                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5288                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5289                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5290                                 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));
5291                         }
5292                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5293                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5294                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5295                 }
5296                 if (r->user_name) {
5297                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5298                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5301                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5302                                 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));
5303                         }
5304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5307                 }
5308                 if (r->document_name) {
5309                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5310                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5313                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5314                                 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));
5315                         }
5316                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5317                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5319                 }
5320                 if (r->data_type) {
5321                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5322                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5324                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5325                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5326                                 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));
5327                         }
5328                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5329                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5331                 }
5332                 if (r->text_status) {
5333                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5334                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5337                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5338                                 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));
5339                         }
5340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5343                 }
5344         }
5345         return NDR_ERR_SUCCESS;
5346 }
5347
5348 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5349 {
5350         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5351         ndr->depth++;
5352         ndr_print_uint32(ndr, "job_id", r->job_id);
5353         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5354         ndr->depth++;
5355         if (r->printer_name) {
5356                 ndr_print_string(ndr, "printer_name", r->printer_name);
5357         }
5358         ndr->depth--;
5359         ndr_print_ptr(ndr, "server_name", r->server_name);
5360         ndr->depth++;
5361         if (r->server_name) {
5362                 ndr_print_string(ndr, "server_name", r->server_name);
5363         }
5364         ndr->depth--;
5365         ndr_print_ptr(ndr, "user_name", r->user_name);
5366         ndr->depth++;
5367         if (r->user_name) {
5368                 ndr_print_string(ndr, "user_name", r->user_name);
5369         }
5370         ndr->depth--;
5371         ndr_print_ptr(ndr, "document_name", r->document_name);
5372         ndr->depth++;
5373         if (r->document_name) {
5374                 ndr_print_string(ndr, "document_name", r->document_name);
5375         }
5376         ndr->depth--;
5377         ndr_print_ptr(ndr, "data_type", r->data_type);
5378         ndr->depth++;
5379         if (r->data_type) {
5380                 ndr_print_string(ndr, "data_type", r->data_type);
5381         }
5382         ndr->depth--;
5383         ndr_print_ptr(ndr, "text_status", r->text_status);
5384         ndr->depth++;
5385         if (r->text_status) {
5386                 ndr_print_string(ndr, "text_status", r->text_status);
5387         }
5388         ndr->depth--;
5389         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5390         ndr_print_uint32(ndr, "priority", r->priority);
5391         ndr_print_uint32(ndr, "position", r->position);
5392         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5393         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5394         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5395         ndr->depth--;
5396 }
5397
5398 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5399 {
5400         if (ndr_flags & NDR_SCALARS) {
5401                 NDR_CHECK(ndr_push_align(ndr, 5));
5402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5406                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5410                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5415                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5422                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5425                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5426         }
5427         if (ndr_flags & NDR_BUFFERS) {
5428                 if (r->printer_name) {
5429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5432                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5433                 }
5434                 if (r->server_name) {
5435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5436                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5438                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5439                 }
5440                 if (r->user_name) {
5441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5445                 }
5446                 if (r->document_name) {
5447                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5448                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5450                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5451                 }
5452                 if (r->notify_name) {
5453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5454                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5456                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5457                 }
5458                 if (r->data_type) {
5459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5461                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5462                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5463                 }
5464                 if (r->print_processor) {
5465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5469                 }
5470                 if (r->parameters) {
5471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5472                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5474                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5475                 }
5476                 if (r->driver_name) {
5477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5478                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5480                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5481                 }
5482                 if (r->text_status) {
5483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5486                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5487                 }
5488         }
5489         return NDR_ERR_SUCCESS;
5490 }
5491
5492 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5493 {
5494         uint32_t _ptr_printer_name;
5495         TALLOC_CTX *_mem_save_printer_name_0;
5496         uint32_t _ptr_server_name;
5497         TALLOC_CTX *_mem_save_server_name_0;
5498         uint32_t _ptr_user_name;
5499         TALLOC_CTX *_mem_save_user_name_0;
5500         uint32_t _ptr_document_name;
5501         TALLOC_CTX *_mem_save_document_name_0;
5502         uint32_t _ptr_notify_name;
5503         TALLOC_CTX *_mem_save_notify_name_0;
5504         uint32_t _ptr_data_type;
5505         TALLOC_CTX *_mem_save_data_type_0;
5506         uint32_t _ptr_print_processor;
5507         TALLOC_CTX *_mem_save_print_processor_0;
5508         uint32_t _ptr_parameters;
5509         TALLOC_CTX *_mem_save_parameters_0;
5510         uint32_t _ptr_driver_name;
5511         TALLOC_CTX *_mem_save_driver_name_0;
5512         uint32_t _ptr_text_status;
5513         TALLOC_CTX *_mem_save_text_status_0;
5514         if (ndr_flags & NDR_SCALARS) {
5515                 NDR_CHECK(ndr_pull_align(ndr, 5));
5516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5518                 if (_ptr_printer_name) {
5519                         NDR_PULL_ALLOC(ndr, r->printer_name);
5520                 } else {
5521                         r->printer_name = NULL;
5522                 }
5523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5524                 if (_ptr_server_name) {
5525                         NDR_PULL_ALLOC(ndr, r->server_name);
5526                 } else {
5527                         r->server_name = NULL;
5528                 }
5529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5530                 if (_ptr_user_name) {
5531                         NDR_PULL_ALLOC(ndr, r->user_name);
5532                 } else {
5533                         r->user_name = NULL;
5534                 }
5535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5536                 if (_ptr_document_name) {
5537                         NDR_PULL_ALLOC(ndr, r->document_name);
5538                 } else {
5539                         r->document_name = NULL;
5540                 }
5541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5542                 if (_ptr_notify_name) {
5543                         NDR_PULL_ALLOC(ndr, r->notify_name);
5544                 } else {
5545                         r->notify_name = NULL;
5546                 }
5547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5548                 if (_ptr_data_type) {
5549                         NDR_PULL_ALLOC(ndr, r->data_type);
5550                 } else {
5551                         r->data_type = NULL;
5552                 }
5553                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5554                 if (_ptr_print_processor) {
5555                         NDR_PULL_ALLOC(ndr, r->print_processor);
5556                 } else {
5557                         r->print_processor = NULL;
5558                 }
5559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5560                 if (_ptr_parameters) {
5561                         NDR_PULL_ALLOC(ndr, r->parameters);
5562                 } else {
5563                         r->parameters = NULL;
5564                 }
5565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5566                 if (_ptr_driver_name) {
5567                         NDR_PULL_ALLOC(ndr, r->driver_name);
5568                 } else {
5569                         r->driver_name = NULL;
5570                 }
5571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5573                 if (_ptr_text_status) {
5574                         NDR_PULL_ALLOC(ndr, r->text_status);
5575                 } else {
5576                         r->text_status = NULL;
5577                 }
5578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5579                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5581                 if (r->priority > 99) {
5582                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5583                 }
5584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5589                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5592                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5593         }
5594         if (ndr_flags & NDR_BUFFERS) {
5595                 if (r->printer_name) {
5596                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5597                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5598                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5599                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5600                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5601                                 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));
5602                         }
5603                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5604                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5606                 }
5607                 if (r->server_name) {
5608                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5609                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5610                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5611                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5612                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5613                                 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));
5614                         }
5615                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5616                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5618                 }
5619                 if (r->user_name) {
5620                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5621                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5622                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5623                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5624                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5625                                 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));
5626                         }
5627                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5628                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5630                 }
5631                 if (r->document_name) {
5632                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5633                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5634                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5635                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5636                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5637                                 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));
5638                         }
5639                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5640                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5642                 }
5643                 if (r->notify_name) {
5644                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5645                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5646                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5647                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5648                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5649                                 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));
5650                         }
5651                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5652                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5654                 }
5655                 if (r->data_type) {
5656                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5657                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5658                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5659                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5660                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5661                                 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));
5662                         }
5663                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5664                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5665                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5666                 }
5667                 if (r->print_processor) {
5668                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5669                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5670                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5671                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5672                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5673                                 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));
5674                         }
5675                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5676                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5678                 }
5679                 if (r->parameters) {
5680                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5681                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5682                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5683                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5684                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5685                                 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));
5686                         }
5687                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5688                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5690                 }
5691                 if (r->driver_name) {
5692                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5693                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5694                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5695                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5696                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5697                                 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));
5698                         }
5699                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5700                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5701                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5702                 }
5703                 if (r->text_status) {
5704                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5705                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5706                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5707                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5708                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5709                                 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));
5710                         }
5711                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5712                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5714                 }
5715         }
5716         return NDR_ERR_SUCCESS;
5717 }
5718
5719 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5720 {
5721         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5722         ndr->depth++;
5723         ndr_print_uint32(ndr, "job_id", r->job_id);
5724         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5725         ndr->depth++;
5726         if (r->printer_name) {
5727                 ndr_print_string(ndr, "printer_name", r->printer_name);
5728         }
5729         ndr->depth--;
5730         ndr_print_ptr(ndr, "server_name", r->server_name);
5731         ndr->depth++;
5732         if (r->server_name) {
5733                 ndr_print_string(ndr, "server_name", r->server_name);
5734         }
5735         ndr->depth--;
5736         ndr_print_ptr(ndr, "user_name", r->user_name);
5737         ndr->depth++;
5738         if (r->user_name) {
5739                 ndr_print_string(ndr, "user_name", r->user_name);
5740         }
5741         ndr->depth--;
5742         ndr_print_ptr(ndr, "document_name", r->document_name);
5743         ndr->depth++;
5744         if (r->document_name) {
5745                 ndr_print_string(ndr, "document_name", r->document_name);
5746         }
5747         ndr->depth--;
5748         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5749         ndr->depth++;
5750         if (r->notify_name) {
5751                 ndr_print_string(ndr, "notify_name", r->notify_name);
5752         }
5753         ndr->depth--;
5754         ndr_print_ptr(ndr, "data_type", r->data_type);
5755         ndr->depth++;
5756         if (r->data_type) {
5757                 ndr_print_string(ndr, "data_type", r->data_type);
5758         }
5759         ndr->depth--;
5760         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5761         ndr->depth++;
5762         if (r->print_processor) {
5763                 ndr_print_string(ndr, "print_processor", r->print_processor);
5764         }
5765         ndr->depth--;
5766         ndr_print_ptr(ndr, "parameters", r->parameters);
5767         ndr->depth++;
5768         if (r->parameters) {
5769                 ndr_print_string(ndr, "parameters", r->parameters);
5770         }
5771         ndr->depth--;
5772         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5773         ndr->depth++;
5774         if (r->driver_name) {
5775                 ndr_print_string(ndr, "driver_name", r->driver_name);
5776         }
5777         ndr->depth--;
5778         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5779         ndr_print_ptr(ndr, "text_status", r->text_status);
5780         ndr->depth++;
5781         if (r->text_status) {
5782                 ndr_print_string(ndr, "text_status", r->text_status);
5783         }
5784         ndr->depth--;
5785         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5786         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5787         ndr_print_uint32(ndr, "priority", r->priority);
5788         ndr_print_uint32(ndr, "position", r->position);
5789         ndr_print_uint32(ndr, "start_time", r->start_time);
5790         ndr_print_uint32(ndr, "until_time", r->until_time);
5791         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5792         ndr_print_uint32(ndr, "size", r->size);
5793         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5794         ndr_print_uint32(ndr, "time", r->time);
5795         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5796         ndr->depth--;
5797 }
5798
5799 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5800 {
5801         if (ndr_flags & NDR_SCALARS) {
5802                 NDR_CHECK(ndr_push_align(ndr, 5));
5803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5816                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5823                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5827                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5828         }
5829         if (ndr_flags & NDR_BUFFERS) {
5830                 if (r->printer_name) {
5831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5834                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5835                 }
5836                 if (r->server_name) {
5837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5840                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5841                 }
5842                 if (r->user_name) {
5843                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5846                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5847                 }
5848                 if (r->document_name) {
5849                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5852                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5853                 }
5854                 if (r->notify_name) {
5855                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5856                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5858                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5859                 }
5860                 if (r->data_type) {
5861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5864                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5865                 }
5866                 if (r->print_processor) {
5867                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5868                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5870                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5871                 }
5872                 if (r->parameters) {
5873                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5874                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5875                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5876                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5877                 }
5878                 if (r->driver_name) {
5879                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5880                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5881                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5882                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5883                 }
5884                 if (r->text_status) {
5885                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5886                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5887                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5888                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5889                 }
5890         }
5891         return NDR_ERR_SUCCESS;
5892 }
5893
5894 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5895 {
5896         uint32_t _ptr_printer_name;
5897         TALLOC_CTX *_mem_save_printer_name_0;
5898         uint32_t _ptr_server_name;
5899         TALLOC_CTX *_mem_save_server_name_0;
5900         uint32_t _ptr_user_name;
5901         TALLOC_CTX *_mem_save_user_name_0;
5902         uint32_t _ptr_document_name;
5903         TALLOC_CTX *_mem_save_document_name_0;
5904         uint32_t _ptr_notify_name;
5905         TALLOC_CTX *_mem_save_notify_name_0;
5906         uint32_t _ptr_data_type;
5907         TALLOC_CTX *_mem_save_data_type_0;
5908         uint32_t _ptr_print_processor;
5909         TALLOC_CTX *_mem_save_print_processor_0;
5910         uint32_t _ptr_parameters;
5911         TALLOC_CTX *_mem_save_parameters_0;
5912         uint32_t _ptr_driver_name;
5913         TALLOC_CTX *_mem_save_driver_name_0;
5914         uint32_t _ptr_text_status;
5915         TALLOC_CTX *_mem_save_text_status_0;
5916         if (ndr_flags & NDR_SCALARS) {
5917                 NDR_CHECK(ndr_pull_align(ndr, 5));
5918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5920                 if (_ptr_printer_name) {
5921                         NDR_PULL_ALLOC(ndr, r->printer_name);
5922                 } else {
5923                         r->printer_name = NULL;
5924                 }
5925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5926                 if (_ptr_server_name) {
5927                         NDR_PULL_ALLOC(ndr, r->server_name);
5928                 } else {
5929                         r->server_name = NULL;
5930                 }
5931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5932                 if (_ptr_user_name) {
5933                         NDR_PULL_ALLOC(ndr, r->user_name);
5934                 } else {
5935                         r->user_name = NULL;
5936                 }
5937                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5938                 if (_ptr_document_name) {
5939                         NDR_PULL_ALLOC(ndr, r->document_name);
5940                 } else {
5941                         r->document_name = NULL;
5942                 }
5943                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5944                 if (_ptr_notify_name) {
5945                         NDR_PULL_ALLOC(ndr, r->notify_name);
5946                 } else {
5947                         r->notify_name = NULL;
5948                 }
5949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5950                 if (_ptr_data_type) {
5951                         NDR_PULL_ALLOC(ndr, r->data_type);
5952                 } else {
5953                         r->data_type = NULL;
5954                 }
5955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5956                 if (_ptr_print_processor) {
5957                         NDR_PULL_ALLOC(ndr, r->print_processor);
5958                 } else {
5959                         r->print_processor = NULL;
5960                 }
5961                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5962                 if (_ptr_parameters) {
5963                         NDR_PULL_ALLOC(ndr, r->parameters);
5964                 } else {
5965                         r->parameters = NULL;
5966                 }
5967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5968                 if (_ptr_driver_name) {
5969                         NDR_PULL_ALLOC(ndr, r->driver_name);
5970                 } else {
5971                         r->driver_name = NULL;
5972                 }
5973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5975                 if (_ptr_text_status) {
5976                         NDR_PULL_ALLOC(ndr, r->text_status);
5977                 } else {
5978                         r->text_status = NULL;
5979                 }
5980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5981                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5983                 if (r->priority > 99) {
5984                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5985                 }
5986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5991                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5995                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5996         }
5997         if (ndr_flags & NDR_BUFFERS) {
5998                 if (r->printer_name) {
5999                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6000                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
6001                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
6002                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
6003                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
6004                                 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));
6005                         }
6006                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
6007                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
6008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
6009                 }
6010                 if (r->server_name) {
6011                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6012                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6013                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6014                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6015                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6016                                 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));
6017                         }
6018                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6019                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6021                 }
6022                 if (r->user_name) {
6023                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6024                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
6025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
6026                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
6027                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
6028                                 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));
6029                         }
6030                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
6031                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
6032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
6033                 }
6034                 if (r->document_name) {
6035                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6036                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
6037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
6038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
6039                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
6040                                 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));
6041                         }
6042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
6043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
6044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
6045                 }
6046                 if (r->notify_name) {
6047                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6048                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
6049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
6050                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
6051                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
6052                                 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));
6053                         }
6054                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6055                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6057                 }
6058                 if (r->data_type) {
6059                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6060                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6062                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6063                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6064                                 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));
6065                         }
6066                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6067                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6069                 }
6070                 if (r->print_processor) {
6071                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6072                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6073                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6074                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6075                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6076                                 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));
6077                         }
6078                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6079                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6081                 }
6082                 if (r->parameters) {
6083                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6084                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6086                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6087                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6088                                 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));
6089                         }
6090                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6093                 }
6094                 if (r->driver_name) {
6095                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6096                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6099                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6100                                 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));
6101                         }
6102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6105                 }
6106                 if (r->text_status) {
6107                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6108                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6110                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6111                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6112                                 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));
6113                         }
6114                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6115                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6117                 }
6118         }
6119         return NDR_ERR_SUCCESS;
6120 }
6121
6122 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6123 {
6124         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6125         ndr->depth++;
6126         ndr_print_uint32(ndr, "job_id", r->job_id);
6127         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6128         ndr->depth++;
6129         if (r->printer_name) {
6130                 ndr_print_string(ndr, "printer_name", r->printer_name);
6131         }
6132         ndr->depth--;
6133         ndr_print_ptr(ndr, "server_name", r->server_name);
6134         ndr->depth++;
6135         if (r->server_name) {
6136                 ndr_print_string(ndr, "server_name", r->server_name);
6137         }
6138         ndr->depth--;
6139         ndr_print_ptr(ndr, "user_name", r->user_name);
6140         ndr->depth++;
6141         if (r->user_name) {
6142                 ndr_print_string(ndr, "user_name", r->user_name);
6143         }
6144         ndr->depth--;
6145         ndr_print_ptr(ndr, "document_name", r->document_name);
6146         ndr->depth++;
6147         if (r->document_name) {
6148                 ndr_print_string(ndr, "document_name", r->document_name);
6149         }
6150         ndr->depth--;
6151         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6152         ndr->depth++;
6153         if (r->notify_name) {
6154                 ndr_print_string(ndr, "notify_name", r->notify_name);
6155         }
6156         ndr->depth--;
6157         ndr_print_ptr(ndr, "data_type", r->data_type);
6158         ndr->depth++;
6159         if (r->data_type) {
6160                 ndr_print_string(ndr, "data_type", r->data_type);
6161         }
6162         ndr->depth--;
6163         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6164         ndr->depth++;
6165         if (r->print_processor) {
6166                 ndr_print_string(ndr, "print_processor", r->print_processor);
6167         }
6168         ndr->depth--;
6169         ndr_print_ptr(ndr, "parameters", r->parameters);
6170         ndr->depth++;
6171         if (r->parameters) {
6172                 ndr_print_string(ndr, "parameters", r->parameters);
6173         }
6174         ndr->depth--;
6175         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6176         ndr->depth++;
6177         if (r->driver_name) {
6178                 ndr_print_string(ndr, "driver_name", r->driver_name);
6179         }
6180         ndr->depth--;
6181         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6182         ndr_print_ptr(ndr, "text_status", r->text_status);
6183         ndr->depth++;
6184         if (r->text_status) {
6185                 ndr_print_string(ndr, "text_status", r->text_status);
6186         }
6187         ndr->depth--;
6188         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6189         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6190         ndr_print_uint32(ndr, "priority", r->priority);
6191         ndr_print_uint32(ndr, "position", r->position);
6192         ndr_print_uint32(ndr, "start_time", r->start_time);
6193         ndr_print_uint32(ndr, "until_time", r->until_time);
6194         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6195         ndr_print_uint32(ndr, "size", r->size);
6196         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6197         ndr_print_uint32(ndr, "time", r->time);
6198         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6199         ndr_print_uint32(ndr, "size_high", r->size_high);
6200         ndr->depth--;
6201 }
6202
6203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6204 {
6205         if (ndr_flags & NDR_SCALARS) {
6206                 int level = ndr_push_get_switch_value(ndr, r);
6207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6208                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6209                 switch (level) {
6210                         case 1: {
6211                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6212                         break; }
6213
6214                         case 2: {
6215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6216                         break; }
6217
6218                         case 3: {
6219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6220                         break; }
6221
6222                         case 4: {
6223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6224                         break; }
6225
6226                         default: {
6227                         break; }
6228
6229                 }
6230         }
6231         if (ndr_flags & NDR_BUFFERS) {
6232                 int level = ndr_push_get_switch_value(ndr, r);
6233                 switch (level) {
6234                         case 1:
6235                                 if (r->info1) {
6236                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6237                                 }
6238                         break;
6239
6240                         case 2:
6241                                 if (r->info2) {
6242                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6243                                 }
6244                         break;
6245
6246                         case 3:
6247                                 if (r->info3) {
6248                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6249                                 }
6250                         break;
6251
6252                         case 4:
6253                                 if (r->info4) {
6254                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6255                                 }
6256                         break;
6257
6258                         default:
6259                         break;
6260
6261                 }
6262         }
6263         return NDR_ERR_SUCCESS;
6264 }
6265
6266 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6267 {
6268         int level;
6269         uint32_t _level;
6270         TALLOC_CTX *_mem_save_info1_0;
6271         TALLOC_CTX *_mem_save_info2_0;
6272         TALLOC_CTX *_mem_save_info3_0;
6273         TALLOC_CTX *_mem_save_info4_0;
6274         level = ndr_pull_get_switch_value(ndr, r);
6275         if (ndr_flags & NDR_SCALARS) {
6276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6277                 if (_level != level) {
6278                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6279                 }
6280                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6281                 switch (level) {
6282                         case 1: {
6283                                 uint32_t _ptr_info1;
6284                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6285                                 if (_ptr_info1) {
6286                                         NDR_PULL_ALLOC(ndr, r->info1);
6287                                 } else {
6288                                         r->info1 = NULL;
6289                                 }
6290                         break; }
6291
6292                         case 2: {
6293                                 uint32_t _ptr_info2;
6294                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6295                                 if (_ptr_info2) {
6296                                         NDR_PULL_ALLOC(ndr, r->info2);
6297                                 } else {
6298                                         r->info2 = NULL;
6299                                 }
6300                         break; }
6301
6302                         case 3: {
6303                                 uint32_t _ptr_info3;
6304                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6305                                 if (_ptr_info3) {
6306                                         NDR_PULL_ALLOC(ndr, r->info3);
6307                                 } else {
6308                                         r->info3 = NULL;
6309                                 }
6310                         break; }
6311
6312                         case 4: {
6313                                 uint32_t _ptr_info4;
6314                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6315                                 if (_ptr_info4) {
6316                                         NDR_PULL_ALLOC(ndr, r->info4);
6317                                 } else {
6318                                         r->info4 = NULL;
6319                                 }
6320                         break; }
6321
6322                         default: {
6323                         break; }
6324
6325                 }
6326         }
6327         if (ndr_flags & NDR_BUFFERS) {
6328                 switch (level) {
6329                         case 1:
6330                                 if (r->info1) {
6331                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6332                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6333                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6334                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6335                                 }
6336                         break;
6337
6338                         case 2:
6339                                 if (r->info2) {
6340                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6341                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6342                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6343                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6344                                 }
6345                         break;
6346
6347                         case 3:
6348                                 if (r->info3) {
6349                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6350                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6351                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6352                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6353                                 }
6354                         break;
6355
6356                         case 4:
6357                                 if (r->info4) {
6358                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6359                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6360                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6361                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6362                                 }
6363                         break;
6364
6365                         default:
6366                         break;
6367
6368                 }
6369         }
6370         return NDR_ERR_SUCCESS;
6371 }
6372
6373 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6374 {
6375         int level;
6376         level = ndr_print_get_switch_value(ndr, r);
6377         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6378         switch (level) {
6379                 case 1:
6380                         ndr_print_ptr(ndr, "info1", r->info1);
6381                         ndr->depth++;
6382                         if (r->info1) {
6383                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6384                         }
6385                         ndr->depth--;
6386                 break;
6387
6388                 case 2:
6389                         ndr_print_ptr(ndr, "info2", r->info2);
6390                         ndr->depth++;
6391                         if (r->info2) {
6392                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6393                         }
6394                         ndr->depth--;
6395                 break;
6396
6397                 case 3:
6398                         ndr_print_ptr(ndr, "info3", r->info3);
6399                         ndr->depth++;
6400                         if (r->info3) {
6401                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6402                         }
6403                         ndr->depth--;
6404                 break;
6405
6406                 case 4:
6407                         ndr_print_ptr(ndr, "info4", r->info4);
6408                         ndr->depth++;
6409                         if (r->info4) {
6410                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6411                         }
6412                         ndr->depth--;
6413                 break;
6414
6415                 default:
6416                 break;
6417
6418         }
6419 }
6420
6421 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6422 {
6423         if (ndr_flags & NDR_SCALARS) {
6424                 NDR_CHECK(ndr_push_align(ndr, 5));
6425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6426                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6427                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6428                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6429         }
6430         if (ndr_flags & NDR_BUFFERS) {
6431                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6432         }
6433         return NDR_ERR_SUCCESS;
6434 }
6435
6436 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6437 {
6438         if (ndr_flags & NDR_SCALARS) {
6439                 NDR_CHECK(ndr_pull_align(ndr, 5));
6440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6441                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6442                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6443                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6444         }
6445         if (ndr_flags & NDR_BUFFERS) {
6446                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6447         }
6448         return NDR_ERR_SUCCESS;
6449 }
6450
6451 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6452 {
6453         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6454         ndr->depth++;
6455         ndr_print_uint32(ndr, "level", r->level);
6456         ndr_print_set_switch_value(ndr, &r->info, r->level);
6457         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6458         ndr->depth--;
6459 }
6460
6461 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6462 {
6463         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6464         return NDR_ERR_SUCCESS;
6465 }
6466
6467 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6468 {
6469         uint32_t v;
6470         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6471         *r = v;
6472         return NDR_ERR_SUCCESS;
6473 }
6474
6475 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6476 {
6477         const char *val = NULL;
6478
6479         switch (r) {
6480                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6481                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6482                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6483                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6484                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6485                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6486                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6487                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6488                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6489         }
6490         ndr_print_enum(ndr, name, "ENUM", val, r);
6491 }
6492
6493 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6494 {
6495         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6496         return NDR_ERR_SUCCESS;
6497 }
6498
6499 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6500 {
6501         uint32_t v;
6502         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6503         *r = v;
6504         return NDR_ERR_SUCCESS;
6505 }
6506
6507 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6508 {
6509         const char *val = NULL;
6510
6511         switch (r) {
6512                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6513                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6514                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6515                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6516                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6517         }
6518         ndr_print_enum(ndr, name, "ENUM", val, r);
6519 }
6520
6521 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6522 {
6523         if (ndr_flags & NDR_SCALARS) {
6524                 NDR_CHECK(ndr_push_align(ndr, 5));
6525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6526                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6530                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6542                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6545                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6549                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6550                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6554                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6555         }
6556         if (ndr_flags & NDR_BUFFERS) {
6557                 if (r->servername) {
6558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6559                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6562                 }
6563                 if (r->printername) {
6564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6565                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6566                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6567                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6568                 }
6569         }
6570         return NDR_ERR_SUCCESS;
6571 }
6572
6573 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6574 {
6575         uint32_t _ptr_servername;
6576         TALLOC_CTX *_mem_save_servername_0;
6577         uint32_t _ptr_printername;
6578         TALLOC_CTX *_mem_save_printername_0;
6579         if (ndr_flags & NDR_SCALARS) {
6580                 NDR_CHECK(ndr_pull_align(ndr, 5));
6581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6582                 if (_ptr_servername) {
6583                         NDR_PULL_ALLOC(ndr, r->servername);
6584                 } else {
6585                         r->servername = NULL;
6586                 }
6587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6588                 if (_ptr_printername) {
6589                         NDR_PULL_ALLOC(ndr, r->printername);
6590                 } else {
6591                         r->printername = NULL;
6592                 }
6593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6596                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6608                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6611                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6615                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6616                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6620                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6621         }
6622         if (ndr_flags & NDR_BUFFERS) {
6623                 if (r->servername) {
6624                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6625                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6626                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6627                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6628                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6629                                 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));
6630                         }
6631                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6632                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6634                 }
6635                 if (r->printername) {
6636                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6637                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6640                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6641                                 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));
6642                         }
6643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6644                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6646                 }
6647         }
6648         return NDR_ERR_SUCCESS;
6649 }
6650
6651 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6652 {
6653         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6654         ndr->depth++;
6655         ndr_print_ptr(ndr, "servername", r->servername);
6656         ndr->depth++;
6657         if (r->servername) {
6658                 ndr_print_string(ndr, "servername", r->servername);
6659         }
6660         ndr->depth--;
6661         ndr_print_ptr(ndr, "printername", r->printername);
6662         ndr->depth++;
6663         if (r->printername) {
6664                 ndr_print_string(ndr, "printername", r->printername);
6665         }
6666         ndr->depth--;
6667         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6668         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6669         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6670         ndr_print_spoolss_Time(ndr, "time", &r->time);
6671         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6672         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6673         ndr_print_uint32(ndr, "version", r->version);
6674         ndr_print_uint32(ndr, "free_build", r->free_build);
6675         ndr_print_uint32(ndr, "spooling", r->spooling);
6676         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6677         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6678         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6679         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6680         ndr_print_uint32(ndr, "job_error", r->job_error);
6681         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6682         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6683         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6684         ndr_print_uint32(ndr, "change_id", r->change_id);
6685         ndr_print_WERROR(ndr, "last_error", r->last_error);
6686         ndr_print_uint32(ndr, "status", r->status);
6687         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6688         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6689         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6690         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6691         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6692         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6693         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6694         ndr->depth--;
6695 }
6696
6697 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6698 {
6699         if (ndr_flags & NDR_SCALARS) {
6700                 NDR_CHECK(ndr_push_align(ndr, 5));
6701                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6705                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6706         }
6707         if (ndr_flags & NDR_BUFFERS) {
6708                 if (r->description) {
6709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6713                 }
6714                 if (r->name) {
6715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6718                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6719                 }
6720                 if (r->comment) {
6721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6725                 }
6726         }
6727         return NDR_ERR_SUCCESS;
6728 }
6729
6730 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6731 {
6732         uint32_t _ptr_description;
6733         TALLOC_CTX *_mem_save_description_0;
6734         uint32_t _ptr_name;
6735         TALLOC_CTX *_mem_save_name_0;
6736         uint32_t _ptr_comment;
6737         TALLOC_CTX *_mem_save_comment_0;
6738         if (ndr_flags & NDR_SCALARS) {
6739                 NDR_CHECK(ndr_pull_align(ndr, 5));
6740                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6742                 if (_ptr_description) {
6743                         NDR_PULL_ALLOC(ndr, r->description);
6744                 } else {
6745                         r->description = NULL;
6746                 }
6747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6748                 if (_ptr_name) {
6749                         NDR_PULL_ALLOC(ndr, r->name);
6750                 } else {
6751                         r->name = NULL;
6752                 }
6753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6754                 if (_ptr_comment) {
6755                         NDR_PULL_ALLOC(ndr, r->comment);
6756                 } else {
6757                         r->comment = NULL;
6758                 }
6759                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6760         }
6761         if (ndr_flags & NDR_BUFFERS) {
6762                 if (r->description) {
6763                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6764                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6767                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6768                                 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));
6769                         }
6770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6773                 }
6774                 if (r->name) {
6775                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6776                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6779                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6780                                 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));
6781                         }
6782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6783                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6785                 }
6786                 if (r->comment) {
6787                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6788                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6791                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6792                                 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));
6793                         }
6794                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6795                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6797                 }
6798         }
6799         return NDR_ERR_SUCCESS;
6800 }
6801
6802 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6803 {
6804         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6805         ndr->depth++;
6806         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6807         ndr_print_ptr(ndr, "description", r->description);
6808         ndr->depth++;
6809         if (r->description) {
6810                 ndr_print_string(ndr, "description", r->description);
6811         }
6812         ndr->depth--;
6813         ndr_print_ptr(ndr, "name", r->name);
6814         ndr->depth++;
6815         if (r->name) {
6816                 ndr_print_string(ndr, "name", r->name);
6817         }
6818         ndr->depth--;
6819         ndr_print_ptr(ndr, "comment", r->comment);
6820         ndr->depth++;
6821         if (r->comment) {
6822                 ndr_print_string(ndr, "comment", r->comment);
6823         }
6824         ndr->depth--;
6825         ndr->depth--;
6826 }
6827
6828 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6829 {
6830         if (ndr_flags & NDR_SCALARS) {
6831                 NDR_CHECK(ndr_push_align(ndr, 5));
6832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
6840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secdesc_ptr));
6845                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6850                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6853                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6854         }
6855         if (ndr_flags & NDR_BUFFERS) {
6856                 if (r->servername) {
6857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6861                 }
6862                 if (r->printername) {
6863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6867                 }
6868                 if (r->sharename) {
6869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6872                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6873                 }
6874                 if (r->portname) {
6875                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6878                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6879                 }
6880                 if (r->drivername) {
6881                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6883                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6884                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6885                 }
6886                 if (r->comment) {
6887                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6888                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6889                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6890                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6891                 }
6892                 if (r->location) {
6893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6894                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6895                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6896                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6897                 }
6898                 if (r->sepfile) {
6899                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6902                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6903                 }
6904                 if (r->printprocessor) {
6905                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6908                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6909                 }
6910                 if (r->datatype) {
6911                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6912                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6913                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6914                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6915                 }
6916                 if (r->parameters) {
6917                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6920                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6921                 }
6922         }
6923         return NDR_ERR_SUCCESS;
6924 }
6925
6926 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6927 {
6928         uint32_t _ptr_servername;
6929         TALLOC_CTX *_mem_save_servername_0;
6930         uint32_t _ptr_printername;
6931         TALLOC_CTX *_mem_save_printername_0;
6932         uint32_t _ptr_sharename;
6933         TALLOC_CTX *_mem_save_sharename_0;
6934         uint32_t _ptr_portname;
6935         TALLOC_CTX *_mem_save_portname_0;
6936         uint32_t _ptr_drivername;
6937         TALLOC_CTX *_mem_save_drivername_0;
6938         uint32_t _ptr_comment;
6939         TALLOC_CTX *_mem_save_comment_0;
6940         uint32_t _ptr_location;
6941         TALLOC_CTX *_mem_save_location_0;
6942         uint32_t _ptr_sepfile;
6943         TALLOC_CTX *_mem_save_sepfile_0;
6944         uint32_t _ptr_printprocessor;
6945         TALLOC_CTX *_mem_save_printprocessor_0;
6946         uint32_t _ptr_datatype;
6947         TALLOC_CTX *_mem_save_datatype_0;
6948         uint32_t _ptr_parameters;
6949         TALLOC_CTX *_mem_save_parameters_0;
6950         if (ndr_flags & NDR_SCALARS) {
6951                 NDR_CHECK(ndr_pull_align(ndr, 5));
6952                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6953                 if (_ptr_servername) {
6954                         NDR_PULL_ALLOC(ndr, r->servername);
6955                 } else {
6956                         r->servername = NULL;
6957                 }
6958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6959                 if (_ptr_printername) {
6960                         NDR_PULL_ALLOC(ndr, r->printername);
6961                 } else {
6962                         r->printername = NULL;
6963                 }
6964                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6965                 if (_ptr_sharename) {
6966                         NDR_PULL_ALLOC(ndr, r->sharename);
6967                 } else {
6968                         r->sharename = NULL;
6969                 }
6970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6971                 if (_ptr_portname) {
6972                         NDR_PULL_ALLOC(ndr, r->portname);
6973                 } else {
6974                         r->portname = NULL;
6975                 }
6976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6977                 if (_ptr_drivername) {
6978                         NDR_PULL_ALLOC(ndr, r->drivername);
6979                 } else {
6980                         r->drivername = NULL;
6981                 }
6982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6983                 if (_ptr_comment) {
6984                         NDR_PULL_ALLOC(ndr, r->comment);
6985                 } else {
6986                         r->comment = NULL;
6987                 }
6988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6989                 if (_ptr_location) {
6990                         NDR_PULL_ALLOC(ndr, r->location);
6991                 } else {
6992                         r->location = NULL;
6993                 }
6994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
6995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6996                 if (_ptr_sepfile) {
6997                         NDR_PULL_ALLOC(ndr, r->sepfile);
6998                 } else {
6999                         r->sepfile = NULL;
7000                 }
7001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
7002                 if (_ptr_printprocessor) {
7003                         NDR_PULL_ALLOC(ndr, r->printprocessor);
7004                 } else {
7005                         r->printprocessor = NULL;
7006                 }
7007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
7008                 if (_ptr_datatype) {
7009                         NDR_PULL_ALLOC(ndr, r->datatype);
7010                 } else {
7011                         r->datatype = NULL;
7012                 }
7013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
7014                 if (_ptr_parameters) {
7015                         NDR_PULL_ALLOC(ndr, r->parameters);
7016                 } else {
7017                         r->parameters = NULL;
7018                 }
7019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secdesc_ptr));
7020                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
7022                 if (r->priority > 99) {
7023                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7024                 }
7025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7028                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7031                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7032         }
7033         if (ndr_flags & NDR_BUFFERS) {
7034                 if (r->servername) {
7035                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7036                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7039                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7040                                 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));
7041                         }
7042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7045                 }
7046                 if (r->printername) {
7047                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7048                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7050                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7051                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7052                                 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));
7053                         }
7054                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7055                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7057                 }
7058                 if (r->sharename) {
7059                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7060                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7062                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7063                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7064                                 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));
7065                         }
7066                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7067                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7069                 }
7070                 if (r->portname) {
7071                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7072                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7073                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7074                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7075                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7076                                 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));
7077                         }
7078                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7079                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7081                 }
7082                 if (r->drivername) {
7083                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7084                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7086                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7087                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7088                                 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));
7089                         }
7090                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7093                 }
7094                 if (r->comment) {
7095                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7096                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7099                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7100                                 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));
7101                         }
7102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7105                 }
7106                 if (r->location) {
7107                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7108                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7110                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7111                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7112                                 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));
7113                         }
7114                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7115                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7117                 }
7118                 if (r->sepfile) {
7119                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7120                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7121                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7122                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7123                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7124                                 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));
7125                         }
7126                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7127                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7128                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7129                 }
7130                 if (r->printprocessor) {
7131                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7132                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7133                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7134                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7135                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7136                                 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));
7137                         }
7138                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7139                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7141                 }
7142                 if (r->datatype) {
7143                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7144                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7145                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7146                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7147                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7148                                 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));
7149                         }
7150                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7151                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7153                 }
7154                 if (r->parameters) {
7155                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7156                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7157                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7158                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7159                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7160                                 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));
7161                         }
7162                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7163                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7164                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7165                 }
7166         }
7167         return NDR_ERR_SUCCESS;
7168 }
7169
7170 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7171 {
7172         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7173         ndr->depth++;
7174         ndr_print_ptr(ndr, "servername", r->servername);
7175         ndr->depth++;
7176         if (r->servername) {
7177                 ndr_print_string(ndr, "servername", r->servername);
7178         }
7179         ndr->depth--;
7180         ndr_print_ptr(ndr, "printername", r->printername);
7181         ndr->depth++;
7182         if (r->printername) {
7183                 ndr_print_string(ndr, "printername", r->printername);
7184         }
7185         ndr->depth--;
7186         ndr_print_ptr(ndr, "sharename", r->sharename);
7187         ndr->depth++;
7188         if (r->sharename) {
7189                 ndr_print_string(ndr, "sharename", r->sharename);
7190         }
7191         ndr->depth--;
7192         ndr_print_ptr(ndr, "portname", r->portname);
7193         ndr->depth++;
7194         if (r->portname) {
7195                 ndr_print_string(ndr, "portname", r->portname);
7196         }
7197         ndr->depth--;
7198         ndr_print_ptr(ndr, "drivername", r->drivername);
7199         ndr->depth++;
7200         if (r->drivername) {
7201                 ndr_print_string(ndr, "drivername", r->drivername);
7202         }
7203         ndr->depth--;
7204         ndr_print_ptr(ndr, "comment", r->comment);
7205         ndr->depth++;
7206         if (r->comment) {
7207                 ndr_print_string(ndr, "comment", r->comment);
7208         }
7209         ndr->depth--;
7210         ndr_print_ptr(ndr, "location", r->location);
7211         ndr->depth++;
7212         if (r->location) {
7213                 ndr_print_string(ndr, "location", r->location);
7214         }
7215         ndr->depth--;
7216         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7217         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7218         ndr->depth++;
7219         if (r->sepfile) {
7220                 ndr_print_string(ndr, "sepfile", r->sepfile);
7221         }
7222         ndr->depth--;
7223         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7224         ndr->depth++;
7225         if (r->printprocessor) {
7226                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7227         }
7228         ndr->depth--;
7229         ndr_print_ptr(ndr, "datatype", r->datatype);
7230         ndr->depth++;
7231         if (r->datatype) {
7232                 ndr_print_string(ndr, "datatype", r->datatype);
7233         }
7234         ndr->depth--;
7235         ndr_print_ptr(ndr, "parameters", r->parameters);
7236         ndr->depth++;
7237         if (r->parameters) {
7238                 ndr_print_string(ndr, "parameters", r->parameters);
7239         }
7240         ndr->depth--;
7241         ndr_print_uint32(ndr, "secdesc_ptr", r->secdesc_ptr);
7242         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7243         ndr_print_uint32(ndr, "priority", r->priority);
7244         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7245         ndr_print_uint32(ndr, "starttime", r->starttime);
7246         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7247         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7248         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7249         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7250         ndr->depth--;
7251 }
7252
7253 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7254 {
7255         if (ndr_flags & NDR_SCALARS) {
7256                 NDR_CHECK(ndr_push_align(ndr, 4));
7257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7258                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7259         }
7260         if (ndr_flags & NDR_BUFFERS) {
7261         }
7262         return NDR_ERR_SUCCESS;
7263 }
7264
7265 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7266 {
7267         if (ndr_flags & NDR_SCALARS) {
7268                 NDR_CHECK(ndr_pull_align(ndr, 4));
7269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7270                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7271         }
7272         if (ndr_flags & NDR_BUFFERS) {
7273         }
7274         return NDR_ERR_SUCCESS;
7275 }
7276
7277 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7278 {
7279         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7280         ndr->depth++;
7281         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7282         ndr->depth--;
7283 }
7284
7285 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7286 {
7287         if (ndr_flags & NDR_SCALARS) {
7288                 NDR_CHECK(ndr_push_align(ndr, 5));
7289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7291                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7292                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7293         }
7294         if (ndr_flags & NDR_BUFFERS) {
7295                 if (r->printername) {
7296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7300                 }
7301                 if (r->servername) {
7302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7305                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7306                 }
7307         }
7308         return NDR_ERR_SUCCESS;
7309 }
7310
7311 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7312 {
7313         uint32_t _ptr_printername;
7314         TALLOC_CTX *_mem_save_printername_0;
7315         uint32_t _ptr_servername;
7316         TALLOC_CTX *_mem_save_servername_0;
7317         if (ndr_flags & NDR_SCALARS) {
7318                 NDR_CHECK(ndr_pull_align(ndr, 5));
7319                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7320                 if (_ptr_printername) {
7321                         NDR_PULL_ALLOC(ndr, r->printername);
7322                 } else {
7323                         r->printername = NULL;
7324                 }
7325                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7326                 if (_ptr_servername) {
7327                         NDR_PULL_ALLOC(ndr, r->servername);
7328                 } else {
7329                         r->servername = NULL;
7330                 }
7331                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7332                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7333         }
7334         if (ndr_flags & NDR_BUFFERS) {
7335                 if (r->printername) {
7336                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7337                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7338                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7339                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7340                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7341                                 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));
7342                         }
7343                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7344                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7346                 }
7347                 if (r->servername) {
7348                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7349                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7350                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7351                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7352                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7353                                 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));
7354                         }
7355                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7356                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7358                 }
7359         }
7360         return NDR_ERR_SUCCESS;
7361 }
7362
7363 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7364 {
7365         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7366         ndr->depth++;
7367         ndr_print_ptr(ndr, "printername", r->printername);
7368         ndr->depth++;
7369         if (r->printername) {
7370                 ndr_print_string(ndr, "printername", r->printername);
7371         }
7372         ndr->depth--;
7373         ndr_print_ptr(ndr, "servername", r->servername);
7374         ndr->depth++;
7375         if (r->servername) {
7376                 ndr_print_string(ndr, "servername", r->servername);
7377         }
7378         ndr->depth--;
7379         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7380         ndr->depth--;
7381 }
7382
7383 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7384 {
7385         if (ndr_flags & NDR_SCALARS) {
7386                 NDR_CHECK(ndr_push_align(ndr, 5));
7387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7389                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7392                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7393         }
7394         if (ndr_flags & NDR_BUFFERS) {
7395                 if (r->printername) {
7396                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7399                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7400                 }
7401                 if (r->portname) {
7402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7405                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7406                 }
7407         }
7408         return NDR_ERR_SUCCESS;
7409 }
7410
7411 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7412 {
7413         uint32_t _ptr_printername;
7414         TALLOC_CTX *_mem_save_printername_0;
7415         uint32_t _ptr_portname;
7416         TALLOC_CTX *_mem_save_portname_0;
7417         if (ndr_flags & NDR_SCALARS) {
7418                 NDR_CHECK(ndr_pull_align(ndr, 5));
7419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7420                 if (_ptr_printername) {
7421                         NDR_PULL_ALLOC(ndr, r->printername);
7422                 } else {
7423                         r->printername = NULL;
7424                 }
7425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7426                 if (_ptr_portname) {
7427                         NDR_PULL_ALLOC(ndr, r->portname);
7428                 } else {
7429                         r->portname = NULL;
7430                 }
7431                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7434                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7435         }
7436         if (ndr_flags & NDR_BUFFERS) {
7437                 if (r->printername) {
7438                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7439                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7440                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7441                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7442                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7443                                 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));
7444                         }
7445                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7446                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7448                 }
7449                 if (r->portname) {
7450                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7451                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7452                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7453                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7454                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7455                                 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));
7456                         }
7457                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7458                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7460                 }
7461         }
7462         return NDR_ERR_SUCCESS;
7463 }
7464
7465 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7466 {
7467         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7468         ndr->depth++;
7469         ndr_print_ptr(ndr, "printername", r->printername);
7470         ndr->depth++;
7471         if (r->printername) {
7472                 ndr_print_string(ndr, "printername", r->printername);
7473         }
7474         ndr->depth--;
7475         ndr_print_ptr(ndr, "portname", r->portname);
7476         ndr->depth++;
7477         if (r->portname) {
7478                 ndr_print_string(ndr, "portname", r->portname);
7479         }
7480         ndr->depth--;
7481         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7482         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7483         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7484         ndr->depth--;
7485 }
7486
7487 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7488 {
7489         if (ndr_flags & NDR_SCALARS) {
7490                 NDR_CHECK(ndr_push_align(ndr, 4));
7491                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7492                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7493         }
7494         if (ndr_flags & NDR_BUFFERS) {
7495         }
7496         return NDR_ERR_SUCCESS;
7497 }
7498
7499 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7500 {
7501         if (ndr_flags & NDR_SCALARS) {
7502                 NDR_CHECK(ndr_pull_align(ndr, 4));
7503                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7504                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7505         }
7506         if (ndr_flags & NDR_BUFFERS) {
7507         }
7508         return NDR_ERR_SUCCESS;
7509 }
7510
7511 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7512 {
7513         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7514         ndr->depth++;
7515         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7516         ndr->depth--;
7517 }
7518
7519 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7520 {
7521         if (ndr_flags & NDR_SCALARS) {
7522                 NDR_CHECK(ndr_push_align(ndr, 5));
7523                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7524                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7525                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7526         }
7527         if (ndr_flags & NDR_BUFFERS) {
7528                 if (r->guid) {
7529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7531                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7532                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7533                 }
7534         }
7535         return NDR_ERR_SUCCESS;
7536 }
7537
7538 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7539 {
7540         uint32_t _ptr_guid;
7541         TALLOC_CTX *_mem_save_guid_0;
7542         if (ndr_flags & NDR_SCALARS) {
7543                 NDR_CHECK(ndr_pull_align(ndr, 5));
7544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7545                 if (_ptr_guid) {
7546                         NDR_PULL_ALLOC(ndr, r->guid);
7547                 } else {
7548                         r->guid = NULL;
7549                 }
7550                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7551                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7552         }
7553         if (ndr_flags & NDR_BUFFERS) {
7554                 if (r->guid) {
7555                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7556                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7559                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7560                                 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));
7561                         }
7562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7565                 }
7566         }
7567         return NDR_ERR_SUCCESS;
7568 }
7569
7570 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7571 {
7572         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7573         ndr->depth++;
7574         ndr_print_ptr(ndr, "guid", r->guid);
7575         ndr->depth++;
7576         if (r->guid) {
7577                 ndr_print_string(ndr, "guid", r->guid);
7578         }
7579         ndr->depth--;
7580         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7581         ndr->depth--;
7582 }
7583
7584 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo8 *r)
7585 {
7586         if (ndr_flags & NDR_SCALARS) {
7587                 NDR_CHECK(ndr_push_align(ndr, 4));
7588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7589                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7590         }
7591         if (ndr_flags & NDR_BUFFERS) {
7592         }
7593         return NDR_ERR_SUCCESS;
7594 }
7595
7596 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo8 *r)
7597 {
7598         if (ndr_flags & NDR_SCALARS) {
7599                 NDR_CHECK(ndr_pull_align(ndr, 4));
7600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7601                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7602         }
7603         if (ndr_flags & NDR_BUFFERS) {
7604         }
7605         return NDR_ERR_SUCCESS;
7606 }
7607
7608 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo8 *r)
7609 {
7610         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo8");
7611         ndr->depth++;
7612         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7613         ndr->depth--;
7614 }
7615
7616 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo9(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo9 *r)
7617 {
7618         if (ndr_flags & NDR_SCALARS) {
7619                 NDR_CHECK(ndr_push_align(ndr, 4));
7620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7621                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7622         }
7623         if (ndr_flags & NDR_BUFFERS) {
7624         }
7625         return NDR_ERR_SUCCESS;
7626 }
7627
7628 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo9(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo9 *r)
7629 {
7630         if (ndr_flags & NDR_SCALARS) {
7631                 NDR_CHECK(ndr_pull_align(ndr, 4));
7632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7633                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7634         }
7635         if (ndr_flags & NDR_BUFFERS) {
7636         }
7637         return NDR_ERR_SUCCESS;
7638 }
7639
7640 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo9(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo9 *r)
7641 {
7642         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo9");
7643         ndr->depth++;
7644         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7645         ndr->depth--;
7646 }
7647
7648 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7649 {
7650         if (ndr_flags & NDR_SCALARS) {
7651                 int level = ndr_push_get_switch_value(ndr, r);
7652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7653                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7654                 switch (level) {
7655                         case 0: {
7656                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7657                         break; }
7658
7659                         case 1: {
7660                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7661                         break; }
7662
7663                         case 2: {
7664                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7665                         break; }
7666
7667                         case 3: {
7668                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7669                         break; }
7670
7671                         case 4: {
7672                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7673                         break; }
7674
7675                         case 5: {
7676                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7677                         break; }
7678
7679                         case 6: {
7680                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7681                         break; }
7682
7683                         case 7: {
7684                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7685                         break; }
7686
7687                         case 8: {
7688                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7689                         break; }
7690
7691                         case 9: {
7692                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7693                         break; }
7694
7695                         default: {
7696                         break; }
7697
7698                 }
7699         }
7700         if (ndr_flags & NDR_BUFFERS) {
7701                 int level = ndr_push_get_switch_value(ndr, r);
7702                 switch (level) {
7703                         case 0:
7704                                 if (r->info0) {
7705                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7706                                 }
7707                         break;
7708
7709                         case 1:
7710                                 if (r->info1) {
7711                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7712                                 }
7713                         break;
7714
7715                         case 2:
7716                                 if (r->info2) {
7717                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7718                                 }
7719                         break;
7720
7721                         case 3:
7722                                 if (r->info3) {
7723                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7724                                 }
7725                         break;
7726
7727                         case 4:
7728                                 if (r->info4) {
7729                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7730                                 }
7731                         break;
7732
7733                         case 5:
7734                                 if (r->info5) {
7735                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7736                                 }
7737                         break;
7738
7739                         case 6:
7740                                 if (r->info6) {
7741                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7742                                 }
7743                         break;
7744
7745                         case 7:
7746                                 if (r->info7) {
7747                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7748                                 }
7749                         break;
7750
7751                         case 8:
7752                                 if (r->info8) {
7753                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7754                                 }
7755                         break;
7756
7757                         case 9:
7758                                 if (r->info9) {
7759                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7760                                 }
7761                         break;
7762
7763                         default:
7764                         break;
7765
7766                 }
7767         }
7768         return NDR_ERR_SUCCESS;
7769 }
7770
7771 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7772 {
7773         int level;
7774         uint32_t _level;
7775         TALLOC_CTX *_mem_save_info0_0;
7776         TALLOC_CTX *_mem_save_info1_0;
7777         TALLOC_CTX *_mem_save_info2_0;
7778         TALLOC_CTX *_mem_save_info3_0;
7779         TALLOC_CTX *_mem_save_info4_0;
7780         TALLOC_CTX *_mem_save_info5_0;
7781         TALLOC_CTX *_mem_save_info6_0;
7782         TALLOC_CTX *_mem_save_info7_0;
7783         TALLOC_CTX *_mem_save_info8_0;
7784         TALLOC_CTX *_mem_save_info9_0;
7785         level = ndr_pull_get_switch_value(ndr, r);
7786         if (ndr_flags & NDR_SCALARS) {
7787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7788                 if (_level != level) {
7789                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7790                 }
7791                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7792                 switch (level) {
7793                         case 0: {
7794                                 uint32_t _ptr_info0;
7795                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7796                                 if (_ptr_info0) {
7797                                         NDR_PULL_ALLOC(ndr, r->info0);
7798                                 } else {
7799                                         r->info0 = NULL;
7800                                 }
7801                         break; }
7802
7803                         case 1: {
7804                                 uint32_t _ptr_info1;
7805                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7806                                 if (_ptr_info1) {
7807                                         NDR_PULL_ALLOC(ndr, r->info1);
7808                                 } else {
7809                                         r->info1 = NULL;
7810                                 }
7811                         break; }
7812
7813                         case 2: {
7814                                 uint32_t _ptr_info2;
7815                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7816                                 if (_ptr_info2) {
7817                                         NDR_PULL_ALLOC(ndr, r->info2);
7818                                 } else {
7819                                         r->info2 = NULL;
7820                                 }
7821                         break; }
7822
7823                         case 3: {
7824                                 uint32_t _ptr_info3;
7825                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7826                                 if (_ptr_info3) {
7827                                         NDR_PULL_ALLOC(ndr, r->info3);
7828                                 } else {
7829                                         r->info3 = NULL;
7830                                 }
7831                         break; }
7832
7833                         case 4: {
7834                                 uint32_t _ptr_info4;
7835                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7836                                 if (_ptr_info4) {
7837                                         NDR_PULL_ALLOC(ndr, r->info4);
7838                                 } else {
7839                                         r->info4 = NULL;
7840                                 }
7841                         break; }
7842
7843                         case 5: {
7844                                 uint32_t _ptr_info5;
7845                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7846                                 if (_ptr_info5) {
7847                                         NDR_PULL_ALLOC(ndr, r->info5);
7848                                 } else {
7849                                         r->info5 = NULL;
7850                                 }
7851                         break; }
7852
7853                         case 6: {
7854                                 uint32_t _ptr_info6;
7855                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7856                                 if (_ptr_info6) {
7857                                         NDR_PULL_ALLOC(ndr, r->info6);
7858                                 } else {
7859                                         r->info6 = NULL;
7860                                 }
7861                         break; }
7862
7863                         case 7: {
7864                                 uint32_t _ptr_info7;
7865                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7866                                 if (_ptr_info7) {
7867                                         NDR_PULL_ALLOC(ndr, r->info7);
7868                                 } else {
7869                                         r->info7 = NULL;
7870                                 }
7871                         break; }
7872
7873                         case 8: {
7874                                 uint32_t _ptr_info8;
7875                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7876                                 if (_ptr_info8) {
7877                                         NDR_PULL_ALLOC(ndr, r->info8);
7878                                 } else {
7879                                         r->info8 = NULL;
7880                                 }
7881                         break; }
7882
7883                         case 9: {
7884                                 uint32_t _ptr_info9;
7885                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7886                                 if (_ptr_info9) {
7887                                         NDR_PULL_ALLOC(ndr, r->info9);
7888                                 } else {
7889                                         r->info9 = NULL;
7890                                 }
7891                         break; }
7892
7893                         default: {
7894                         break; }
7895
7896                 }
7897         }
7898         if (ndr_flags & NDR_BUFFERS) {
7899                 switch (level) {
7900                         case 0:
7901                                 if (r->info0) {
7902                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7903                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7904                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7905                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7906                                 }
7907                         break;
7908
7909                         case 1:
7910                                 if (r->info1) {
7911                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7912                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7913                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7914                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7915                                 }
7916                         break;
7917
7918                         case 2:
7919                                 if (r->info2) {
7920                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7921                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7922                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7923                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7924                                 }
7925                         break;
7926
7927                         case 3:
7928                                 if (r->info3) {
7929                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7930                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7931                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7932                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7933                                 }
7934                         break;
7935
7936                         case 4:
7937                                 if (r->info4) {
7938                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7939                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7940                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7941                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7942                                 }
7943                         break;
7944
7945                         case 5:
7946                                 if (r->info5) {
7947                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7948                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7949                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7950                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7951                                 }
7952                         break;
7953
7954                         case 6:
7955                                 if (r->info6) {
7956                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7957                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7958                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7959                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7960                                 }
7961                         break;
7962
7963                         case 7:
7964                                 if (r->info7) {
7965                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7966                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7967                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7968                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7969                                 }
7970                         break;
7971
7972                         case 8:
7973                                 if (r->info8) {
7974                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7975                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7976                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7977                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7978                                 }
7979                         break;
7980
7981                         case 9:
7982                                 if (r->info9) {
7983                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7984                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7985                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7986                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7987                                 }
7988                         break;
7989
7990                         default:
7991                         break;
7992
7993                 }
7994         }
7995         return NDR_ERR_SUCCESS;
7996 }
7997
7998 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7999 {
8000         int level;
8001         level = ndr_print_get_switch_value(ndr, r);
8002         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
8003         switch (level) {
8004                 case 0:
8005                         ndr_print_ptr(ndr, "info0", r->info0);
8006                         ndr->depth++;
8007                         if (r->info0) {
8008                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
8009                         }
8010                         ndr->depth--;
8011                 break;
8012
8013                 case 1:
8014                         ndr_print_ptr(ndr, "info1", r->info1);
8015                         ndr->depth++;
8016                         if (r->info1) {
8017                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
8018                         }
8019                         ndr->depth--;
8020                 break;
8021
8022                 case 2:
8023                         ndr_print_ptr(ndr, "info2", r->info2);
8024                         ndr->depth++;
8025                         if (r->info2) {
8026                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
8027                         }
8028                         ndr->depth--;
8029                 break;
8030
8031                 case 3:
8032                         ndr_print_ptr(ndr, "info3", r->info3);
8033                         ndr->depth++;
8034                         if (r->info3) {
8035                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
8036                         }
8037                         ndr->depth--;
8038                 break;
8039
8040                 case 4:
8041                         ndr_print_ptr(ndr, "info4", r->info4);
8042                         ndr->depth++;
8043                         if (r->info4) {
8044                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
8045                         }
8046                         ndr->depth--;
8047                 break;
8048
8049                 case 5:
8050                         ndr_print_ptr(ndr, "info5", r->info5);
8051                         ndr->depth++;
8052                         if (r->info5) {
8053                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
8054                         }
8055                         ndr->depth--;
8056                 break;
8057
8058                 case 6:
8059                         ndr_print_ptr(ndr, "info6", r->info6);
8060                         ndr->depth++;
8061                         if (r->info6) {
8062                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8063                         }
8064                         ndr->depth--;
8065                 break;
8066
8067                 case 7:
8068                         ndr_print_ptr(ndr, "info7", r->info7);
8069                         ndr->depth++;
8070                         if (r->info7) {
8071                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8072                         }
8073                         ndr->depth--;
8074                 break;
8075
8076                 case 8:
8077                         ndr_print_ptr(ndr, "info8", r->info8);
8078                         ndr->depth++;
8079                         if (r->info8) {
8080                                 ndr_print_spoolss_SetPrinterInfo8(ndr, "info8", r->info8);
8081                         }
8082                         ndr->depth--;
8083                 break;
8084
8085                 case 9:
8086                         ndr_print_ptr(ndr, "info9", r->info9);
8087                         ndr->depth++;
8088                         if (r->info9) {
8089                                 ndr_print_spoolss_SetPrinterInfo9(ndr, "info9", r->info9);
8090                         }
8091                         ndr->depth--;
8092                 break;
8093
8094                 default:
8095                 break;
8096
8097         }
8098 }
8099
8100 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8101 {
8102         if (ndr_flags & NDR_SCALARS) {
8103                 NDR_CHECK(ndr_push_align(ndr, 5));
8104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8105                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8106                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8107                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8108         }
8109         if (ndr_flags & NDR_BUFFERS) {
8110                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8111         }
8112         return NDR_ERR_SUCCESS;
8113 }
8114
8115 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8116 {
8117         if (ndr_flags & NDR_SCALARS) {
8118                 NDR_CHECK(ndr_pull_align(ndr, 5));
8119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8120                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8121                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8122                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8123         }
8124         if (ndr_flags & NDR_BUFFERS) {
8125                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8126         }
8127         return NDR_ERR_SUCCESS;
8128 }
8129
8130 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8131 {
8132         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8133         ndr->depth++;
8134         ndr_print_uint32(ndr, "level", r->level);
8135         ndr_print_set_switch_value(ndr, &r->info, r->level);
8136         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8137         ndr->depth--;
8138 }
8139
8140 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8141 {
8142         if (ndr_flags & NDR_SCALARS) {
8143                 NDR_CHECK(ndr_push_align(ndr, 4));
8144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8145                 {
8146                         uint32_t _flags_save_string_array = ndr->flags;
8147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8148                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8149                         ndr->flags = _flags_save_string_array;
8150                 }
8151                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8152         }
8153         if (ndr_flags & NDR_BUFFERS) {
8154         }
8155         return NDR_ERR_SUCCESS;
8156 }
8157
8158 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8159 {
8160         if (ndr_flags & NDR_SCALARS) {
8161                 NDR_CHECK(ndr_pull_align(ndr, 4));
8162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8163                 {
8164                         uint32_t _flags_save_string_array = ndr->flags;
8165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8166                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8167                         ndr->flags = _flags_save_string_array;
8168                 }
8169                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8170         }
8171         if (ndr_flags & NDR_BUFFERS) {
8172         }
8173         return NDR_ERR_SUCCESS;
8174 }
8175
8176 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8177 {
8178         ndr_print_struct(ndr, name, "spoolss_StringArray");
8179         ndr->depth++;
8180         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);
8181         ndr_print_string_array(ndr, "string", r->string);
8182         ndr->depth--;
8183 }
8184
8185 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8186 {
8187         if (ndr_flags & NDR_SCALARS) {
8188                 NDR_CHECK(ndr_push_align(ndr, 5));
8189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8190                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8191         }
8192         if (ndr_flags & NDR_BUFFERS) {
8193                 if (r->driver_name) {
8194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8198                 }
8199         }
8200         return NDR_ERR_SUCCESS;
8201 }
8202
8203 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8204 {
8205         uint32_t _ptr_driver_name;
8206         TALLOC_CTX *_mem_save_driver_name_0;
8207         if (ndr_flags & NDR_SCALARS) {
8208                 NDR_CHECK(ndr_pull_align(ndr, 5));
8209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8210                 if (_ptr_driver_name) {
8211                         NDR_PULL_ALLOC(ndr, r->driver_name);
8212                 } else {
8213                         r->driver_name = NULL;
8214                 }
8215                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8216         }
8217         if (ndr_flags & NDR_BUFFERS) {
8218                 if (r->driver_name) {
8219                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8220                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8221                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8222                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8223                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8224                                 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));
8225                         }
8226                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8227                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8229                 }
8230         }
8231         return NDR_ERR_SUCCESS;
8232 }
8233
8234 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8235 {
8236         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8237         ndr->depth++;
8238         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8239         ndr->depth++;
8240         if (r->driver_name) {
8241                 ndr_print_string(ndr, "driver_name", r->driver_name);
8242         }
8243         ndr->depth--;
8244         ndr->depth--;
8245 }
8246
8247 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8248 {
8249         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8250         return NDR_ERR_SUCCESS;
8251 }
8252
8253 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8254 {
8255         uint32_t v;
8256         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8257         *r = v;
8258         return NDR_ERR_SUCCESS;
8259 }
8260
8261 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8262 {
8263         const char *val = NULL;
8264
8265         switch (r) {
8266                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8267                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8268                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8269                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8270         }
8271         ndr_print_enum(ndr, name, "ENUM", val, r);
8272 }
8273
8274 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8275 {
8276         if (ndr_flags & NDR_SCALARS) {
8277                 NDR_CHECK(ndr_push_align(ndr, 5));
8278                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8279                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8280                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8281                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8284                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8285         }
8286         if (ndr_flags & NDR_BUFFERS) {
8287                 if (r->driver_name) {
8288                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8291                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8292                 }
8293                 if (r->architecture) {
8294                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8295                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8297                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8298                 }
8299                 if (r->driver_path) {
8300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8303                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8304                 }
8305                 if (r->data_file) {
8306                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8307                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8308                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8309                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8310                 }
8311                 if (r->config_file) {
8312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8313                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8314                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8315                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8316                 }
8317         }
8318         return NDR_ERR_SUCCESS;
8319 }
8320
8321 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8322 {
8323         uint32_t _ptr_driver_name;
8324         TALLOC_CTX *_mem_save_driver_name_0;
8325         uint32_t _ptr_architecture;
8326         TALLOC_CTX *_mem_save_architecture_0;
8327         uint32_t _ptr_driver_path;
8328         TALLOC_CTX *_mem_save_driver_path_0;
8329         uint32_t _ptr_data_file;
8330         TALLOC_CTX *_mem_save_data_file_0;
8331         uint32_t _ptr_config_file;
8332         TALLOC_CTX *_mem_save_config_file_0;
8333         if (ndr_flags & NDR_SCALARS) {
8334                 NDR_CHECK(ndr_pull_align(ndr, 5));
8335                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8337                 if (_ptr_driver_name) {
8338                         NDR_PULL_ALLOC(ndr, r->driver_name);
8339                 } else {
8340                         r->driver_name = NULL;
8341                 }
8342                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8343                 if (_ptr_architecture) {
8344                         NDR_PULL_ALLOC(ndr, r->architecture);
8345                 } else {
8346                         r->architecture = NULL;
8347                 }
8348                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8349                 if (_ptr_driver_path) {
8350                         NDR_PULL_ALLOC(ndr, r->driver_path);
8351                 } else {
8352                         r->driver_path = NULL;
8353                 }
8354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8355                 if (_ptr_data_file) {
8356                         NDR_PULL_ALLOC(ndr, r->data_file);
8357                 } else {
8358                         r->data_file = NULL;
8359                 }
8360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8361                 if (_ptr_config_file) {
8362                         NDR_PULL_ALLOC(ndr, r->config_file);
8363                 } else {
8364                         r->config_file = NULL;
8365                 }
8366                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8367         }
8368         if (ndr_flags & NDR_BUFFERS) {
8369                 if (r->driver_name) {
8370                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8371                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8374                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8375                                 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));
8376                         }
8377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8380                 }
8381                 if (r->architecture) {
8382                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8383                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8386                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8387                                 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));
8388                         }
8389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8392                 }
8393                 if (r->driver_path) {
8394                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8395                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8398                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8399                                 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));
8400                         }
8401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8404                 }
8405                 if (r->data_file) {
8406                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8407                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8408                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8409                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8410                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8411                                 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));
8412                         }
8413                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8414                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8416                 }
8417                 if (r->config_file) {
8418                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8419                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8421                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8422                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8423                                 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));
8424                         }
8425                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8426                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8428                 }
8429         }
8430         return NDR_ERR_SUCCESS;
8431 }
8432
8433 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8434 {
8435         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8436         ndr->depth++;
8437         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8438         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8439         ndr->depth++;
8440         if (r->driver_name) {
8441                 ndr_print_string(ndr, "driver_name", r->driver_name);
8442         }
8443         ndr->depth--;
8444         ndr_print_ptr(ndr, "architecture", r->architecture);
8445         ndr->depth++;
8446         if (r->architecture) {
8447                 ndr_print_string(ndr, "architecture", r->architecture);
8448         }
8449         ndr->depth--;
8450         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8451         ndr->depth++;
8452         if (r->driver_path) {
8453                 ndr_print_string(ndr, "driver_path", r->driver_path);
8454         }
8455         ndr->depth--;
8456         ndr_print_ptr(ndr, "data_file", r->data_file);
8457         ndr->depth++;
8458         if (r->data_file) {
8459                 ndr_print_string(ndr, "data_file", r->data_file);
8460         }
8461         ndr->depth--;
8462         ndr_print_ptr(ndr, "config_file", r->config_file);
8463         ndr->depth++;
8464         if (r->config_file) {
8465                 ndr_print_string(ndr, "config_file", r->config_file);
8466         }
8467         ndr->depth--;
8468         ndr->depth--;
8469 }
8470
8471 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8472 {
8473         if (ndr_flags & NDR_SCALARS) {
8474                 NDR_CHECK(ndr_push_align(ndr, 5));
8475                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8476                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8479                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8480                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8483                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8486                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8487         }
8488         if (ndr_flags & NDR_BUFFERS) {
8489                 if (r->driver_name) {
8490                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8491                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8492                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8493                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8494                 }
8495                 if (r->architecture) {
8496                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8497                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8498                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8499                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8500                 }
8501                 if (r->driver_path) {
8502                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8505                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8506                 }
8507                 if (r->data_file) {
8508                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8511                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8512                 }
8513                 if (r->config_file) {
8514                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8515                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8516                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8517                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8518                 }
8519                 if (r->help_file) {
8520                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8523                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8524                 }
8525                 if (r->monitor_name) {
8526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8529                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8530                 }
8531                 if (r->default_datatype) {
8532                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8535                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8536                 }
8537                 if (r->dependent_files) {
8538                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8539                 }
8540         }
8541         return NDR_ERR_SUCCESS;
8542 }
8543
8544 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8545 {
8546         uint32_t _ptr_driver_name;
8547         TALLOC_CTX *_mem_save_driver_name_0;
8548         uint32_t _ptr_architecture;
8549         TALLOC_CTX *_mem_save_architecture_0;
8550         uint32_t _ptr_driver_path;
8551         TALLOC_CTX *_mem_save_driver_path_0;
8552         uint32_t _ptr_data_file;
8553         TALLOC_CTX *_mem_save_data_file_0;
8554         uint32_t _ptr_config_file;
8555         TALLOC_CTX *_mem_save_config_file_0;
8556         uint32_t _ptr_help_file;
8557         TALLOC_CTX *_mem_save_help_file_0;
8558         uint32_t _ptr_monitor_name;
8559         TALLOC_CTX *_mem_save_monitor_name_0;
8560         uint32_t _ptr_default_datatype;
8561         TALLOC_CTX *_mem_save_default_datatype_0;
8562         uint32_t _ptr_dependent_files;
8563         TALLOC_CTX *_mem_save_dependent_files_0;
8564         if (ndr_flags & NDR_SCALARS) {
8565                 NDR_CHECK(ndr_pull_align(ndr, 5));
8566                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8568                 if (_ptr_driver_name) {
8569                         NDR_PULL_ALLOC(ndr, r->driver_name);
8570                 } else {
8571                         r->driver_name = NULL;
8572                 }
8573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8574                 if (_ptr_architecture) {
8575                         NDR_PULL_ALLOC(ndr, r->architecture);
8576                 } else {
8577                         r->architecture = NULL;
8578                 }
8579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8580                 if (_ptr_driver_path) {
8581                         NDR_PULL_ALLOC(ndr, r->driver_path);
8582                 } else {
8583                         r->driver_path = NULL;
8584                 }
8585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8586                 if (_ptr_data_file) {
8587                         NDR_PULL_ALLOC(ndr, r->data_file);
8588                 } else {
8589                         r->data_file = NULL;
8590                 }
8591                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8592                 if (_ptr_config_file) {
8593                         NDR_PULL_ALLOC(ndr, r->config_file);
8594                 } else {
8595                         r->config_file = NULL;
8596                 }
8597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8598                 if (_ptr_help_file) {
8599                         NDR_PULL_ALLOC(ndr, r->help_file);
8600                 } else {
8601                         r->help_file = NULL;
8602                 }
8603                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8604                 if (_ptr_monitor_name) {
8605                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8606                 } else {
8607                         r->monitor_name = NULL;
8608                 }
8609                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8610                 if (_ptr_default_datatype) {
8611                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8612                 } else {
8613                         r->default_datatype = NULL;
8614                 }
8615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8617                 if (_ptr_dependent_files) {
8618                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8619                 } else {
8620                         r->dependent_files = NULL;
8621                 }
8622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8623         }
8624         if (ndr_flags & NDR_BUFFERS) {
8625                 if (r->driver_name) {
8626                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8627                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8629                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8630                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8631                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8632                         }
8633                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8634                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8636                 }
8637                 if (r->architecture) {
8638                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8639                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8640                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8641                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8642                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8643                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8644                         }
8645                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8646                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8648                 }
8649                 if (r->driver_path) {
8650                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8651                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8654                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8655                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8656                         }
8657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8658                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8660                 }
8661                 if (r->data_file) {
8662                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8663                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8666                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8667                                 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));
8668                         }
8669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8672                 }
8673                 if (r->config_file) {
8674                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8675                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8676                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8677                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8678                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8679                                 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));
8680                         }
8681                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8682                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8683                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8684                 }
8685                 if (r->help_file) {
8686                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8687                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8688                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8689                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8690                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8691                                 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));
8692                         }
8693                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8694                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8696                 }
8697                 if (r->monitor_name) {
8698                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8699                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8700                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8701                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8702                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8703                                 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));
8704                         }
8705                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8706                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8707                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8708                 }
8709                 if (r->default_datatype) {
8710                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8711                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8712                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8713                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8714                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8715                                 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));
8716                         }
8717                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8718                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8720                 }
8721                 if (r->dependent_files) {
8722                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8723                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8724                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8726                 }
8727         }
8728         return NDR_ERR_SUCCESS;
8729 }
8730
8731 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8732 {
8733         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8734         ndr->depth++;
8735         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8736         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8737         ndr->depth++;
8738         if (r->driver_name) {
8739                 ndr_print_string(ndr, "driver_name", r->driver_name);
8740         }
8741         ndr->depth--;
8742         ndr_print_ptr(ndr, "architecture", r->architecture);
8743         ndr->depth++;
8744         if (r->architecture) {
8745                 ndr_print_string(ndr, "architecture", r->architecture);
8746         }
8747         ndr->depth--;
8748         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8749         ndr->depth++;
8750         if (r->driver_path) {
8751                 ndr_print_string(ndr, "driver_path", r->driver_path);
8752         }
8753         ndr->depth--;
8754         ndr_print_ptr(ndr, "data_file", r->data_file);
8755         ndr->depth++;
8756         if (r->data_file) {
8757                 ndr_print_string(ndr, "data_file", r->data_file);
8758         }
8759         ndr->depth--;
8760         ndr_print_ptr(ndr, "config_file", r->config_file);
8761         ndr->depth++;
8762         if (r->config_file) {
8763                 ndr_print_string(ndr, "config_file", r->config_file);
8764         }
8765         ndr->depth--;
8766         ndr_print_ptr(ndr, "help_file", r->help_file);
8767         ndr->depth++;
8768         if (r->help_file) {
8769                 ndr_print_string(ndr, "help_file", r->help_file);
8770         }
8771         ndr->depth--;
8772         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8773         ndr->depth++;
8774         if (r->monitor_name) {
8775                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8776         }
8777         ndr->depth--;
8778         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8779         ndr->depth++;
8780         if (r->default_datatype) {
8781                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8782         }
8783         ndr->depth--;
8784         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);
8785         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8786         ndr->depth++;
8787         if (r->dependent_files) {
8788                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8789         }
8790         ndr->depth--;
8791         ndr->depth--;
8792 }
8793
8794 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8795 {
8796         if (ndr_flags & NDR_SCALARS) {
8797                 NDR_CHECK(ndr_push_align(ndr, 5));
8798                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8811                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8812         }
8813         if (ndr_flags & NDR_BUFFERS) {
8814                 if (r->driver_name) {
8815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8817                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8818                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8819                 }
8820                 if (r->architecture) {
8821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8823                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8824                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8825                 }
8826                 if (r->driver_path) {
8827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8829                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8830                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8831                 }
8832                 if (r->data_file) {
8833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8835                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8836                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8837                 }
8838                 if (r->config_file) {
8839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8843                 }
8844                 if (r->help_file) {
8845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8848                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8849                 }
8850                 if (r->monitor_name) {
8851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8854                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8855                 }
8856                 if (r->default_datatype) {
8857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8861                 }
8862                 if (r->dependent_files) {
8863                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8864                 }
8865                 if (r->previous_names) {
8866                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8867                 }
8868         }
8869         return NDR_ERR_SUCCESS;
8870 }
8871
8872 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8873 {
8874         uint32_t _ptr_driver_name;
8875         TALLOC_CTX *_mem_save_driver_name_0;
8876         uint32_t _ptr_architecture;
8877         TALLOC_CTX *_mem_save_architecture_0;
8878         uint32_t _ptr_driver_path;
8879         TALLOC_CTX *_mem_save_driver_path_0;
8880         uint32_t _ptr_data_file;
8881         TALLOC_CTX *_mem_save_data_file_0;
8882         uint32_t _ptr_config_file;
8883         TALLOC_CTX *_mem_save_config_file_0;
8884         uint32_t _ptr_help_file;
8885         TALLOC_CTX *_mem_save_help_file_0;
8886         uint32_t _ptr_monitor_name;
8887         TALLOC_CTX *_mem_save_monitor_name_0;
8888         uint32_t _ptr_default_datatype;
8889         TALLOC_CTX *_mem_save_default_datatype_0;
8890         uint32_t _ptr_dependent_files;
8891         TALLOC_CTX *_mem_save_dependent_files_0;
8892         uint32_t _ptr_previous_names;
8893         TALLOC_CTX *_mem_save_previous_names_0;
8894         if (ndr_flags & NDR_SCALARS) {
8895                 NDR_CHECK(ndr_pull_align(ndr, 5));
8896                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8898                 if (_ptr_driver_name) {
8899                         NDR_PULL_ALLOC(ndr, r->driver_name);
8900                 } else {
8901                         r->driver_name = NULL;
8902                 }
8903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8904                 if (_ptr_architecture) {
8905                         NDR_PULL_ALLOC(ndr, r->architecture);
8906                 } else {
8907                         r->architecture = NULL;
8908                 }
8909                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8910                 if (_ptr_driver_path) {
8911                         NDR_PULL_ALLOC(ndr, r->driver_path);
8912                 } else {
8913                         r->driver_path = NULL;
8914                 }
8915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8916                 if (_ptr_data_file) {
8917                         NDR_PULL_ALLOC(ndr, r->data_file);
8918                 } else {
8919                         r->data_file = NULL;
8920                 }
8921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8922                 if (_ptr_config_file) {
8923                         NDR_PULL_ALLOC(ndr, r->config_file);
8924                 } else {
8925                         r->config_file = NULL;
8926                 }
8927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8928                 if (_ptr_help_file) {
8929                         NDR_PULL_ALLOC(ndr, r->help_file);
8930                 } else {
8931                         r->help_file = NULL;
8932                 }
8933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8934                 if (_ptr_monitor_name) {
8935                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8936                 } else {
8937                         r->monitor_name = NULL;
8938                 }
8939                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8940                 if (_ptr_default_datatype) {
8941                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8942                 } else {
8943                         r->default_datatype = NULL;
8944                 }
8945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8946                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8947                 if (_ptr_dependent_files) {
8948                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8949                 } else {
8950                         r->dependent_files = NULL;
8951                 }
8952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8954                 if (_ptr_previous_names) {
8955                         NDR_PULL_ALLOC(ndr, r->previous_names);
8956                 } else {
8957                         r->previous_names = NULL;
8958                 }
8959                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8960         }
8961         if (ndr_flags & NDR_BUFFERS) {
8962                 if (r->driver_name) {
8963                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8964                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8965                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8966                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8967                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8968                                 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));
8969                         }
8970                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8971                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8972                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8973                 }
8974                 if (r->architecture) {
8975                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8976                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8978                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8979                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8980                                 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));
8981                         }
8982                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8983                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8985                 }
8986                 if (r->driver_path) {
8987                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8988                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8989                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8990                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8991                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8992                                 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));
8993                         }
8994                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8995                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8997                 }
8998                 if (r->data_file) {
8999                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9000                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9001                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9002                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9003                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9004                                 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));
9005                         }
9006                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9007                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9009                 }
9010                 if (r->config_file) {
9011                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9012                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9013                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9014                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9015                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9016                                 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));
9017                         }
9018                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9019                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9021                 }
9022                 if (r->help_file) {
9023                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9024                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9026                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9027                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9028                                 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));
9029                         }
9030                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9031                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9033                 }
9034                 if (r->monitor_name) {
9035                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9036                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9039                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9040                                 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));
9041                         }
9042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9045                 }
9046                 if (r->default_datatype) {
9047                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9048                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9050                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9051                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9052                                 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));
9053                         }
9054                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9055                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9057                 }
9058                 if (r->dependent_files) {
9059                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9060                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9061                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9063                 }
9064                 if (r->previous_names) {
9065                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9066                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9067                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9069                 }
9070         }
9071         return NDR_ERR_SUCCESS;
9072 }
9073
9074 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9075 {
9076         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9077         ndr->depth++;
9078         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9079         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9080         ndr->depth++;
9081         if (r->driver_name) {
9082                 ndr_print_string(ndr, "driver_name", r->driver_name);
9083         }
9084         ndr->depth--;
9085         ndr_print_ptr(ndr, "architecture", r->architecture);
9086         ndr->depth++;
9087         if (r->architecture) {
9088                 ndr_print_string(ndr, "architecture", r->architecture);
9089         }
9090         ndr->depth--;
9091         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9092         ndr->depth++;
9093         if (r->driver_path) {
9094                 ndr_print_string(ndr, "driver_path", r->driver_path);
9095         }
9096         ndr->depth--;
9097         ndr_print_ptr(ndr, "data_file", r->data_file);
9098         ndr->depth++;
9099         if (r->data_file) {
9100                 ndr_print_string(ndr, "data_file", r->data_file);
9101         }
9102         ndr->depth--;
9103         ndr_print_ptr(ndr, "config_file", r->config_file);
9104         ndr->depth++;
9105         if (r->config_file) {
9106                 ndr_print_string(ndr, "config_file", r->config_file);
9107         }
9108         ndr->depth--;
9109         ndr_print_ptr(ndr, "help_file", r->help_file);
9110         ndr->depth++;
9111         if (r->help_file) {
9112                 ndr_print_string(ndr, "help_file", r->help_file);
9113         }
9114         ndr->depth--;
9115         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9116         ndr->depth++;
9117         if (r->monitor_name) {
9118                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9119         }
9120         ndr->depth--;
9121         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9122         ndr->depth++;
9123         if (r->default_datatype) {
9124                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9125         }
9126         ndr->depth--;
9127         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);
9128         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9129         ndr->depth++;
9130         if (r->dependent_files) {
9131                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9132         }
9133         ndr->depth--;
9134         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);
9135         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9136         ndr->depth++;
9137         if (r->previous_names) {
9138                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9139         }
9140         ndr->depth--;
9141         ndr->depth--;
9142 }
9143
9144 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9145 {
9146         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9147         return NDR_ERR_SUCCESS;
9148 }
9149
9150 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9151 {
9152         uint32_t v;
9153         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9154         *r = v;
9155         return NDR_ERR_SUCCESS;
9156 }
9157
9158 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9159 {
9160         ndr_print_uint32(ndr, name, r);
9161         ndr->depth++;
9162         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9163         ndr->depth--;
9164 }
9165
9166 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9167 {
9168         if (ndr_flags & NDR_SCALARS) {
9169                 NDR_CHECK(ndr_push_align(ndr, 8));
9170                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9173                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9176                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9178                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9183                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9184                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9189                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9190         }
9191         if (ndr_flags & NDR_BUFFERS) {
9192                 if (r->driver_name) {
9193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9197                 }
9198                 if (r->architecture) {
9199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9203                 }
9204                 if (r->driver_path) {
9205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9208                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9209                 }
9210                 if (r->data_file) {
9211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9214                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9215                 }
9216                 if (r->config_file) {
9217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9221                 }
9222                 if (r->help_file) {
9223                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9226                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9227                 }
9228                 if (r->monitor_name) {
9229                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9232                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9233                 }
9234                 if (r->default_datatype) {
9235                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9236                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9238                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9239                 }
9240                 if (r->dependent_files) {
9241                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9242                 }
9243                 if (r->previous_names) {
9244                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9245                 }
9246                 if (r->manufacturer_name) {
9247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9251                 }
9252                 if (r->manufacturer_url) {
9253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9256                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9257                 }
9258                 if (r->hardware_id) {
9259                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9261                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9263                 }
9264                 if (r->provider) {
9265                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9266                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9267                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9268                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9269                 }
9270         }
9271         return NDR_ERR_SUCCESS;
9272 }
9273
9274 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9275 {
9276         uint32_t _ptr_driver_name;
9277         TALLOC_CTX *_mem_save_driver_name_0;
9278         uint32_t _ptr_architecture;
9279         TALLOC_CTX *_mem_save_architecture_0;
9280         uint32_t _ptr_driver_path;
9281         TALLOC_CTX *_mem_save_driver_path_0;
9282         uint32_t _ptr_data_file;
9283         TALLOC_CTX *_mem_save_data_file_0;
9284         uint32_t _ptr_config_file;
9285         TALLOC_CTX *_mem_save_config_file_0;
9286         uint32_t _ptr_help_file;
9287         TALLOC_CTX *_mem_save_help_file_0;
9288         uint32_t _ptr_monitor_name;
9289         TALLOC_CTX *_mem_save_monitor_name_0;
9290         uint32_t _ptr_default_datatype;
9291         TALLOC_CTX *_mem_save_default_datatype_0;
9292         uint32_t _ptr_dependent_files;
9293         TALLOC_CTX *_mem_save_dependent_files_0;
9294         uint32_t _ptr_previous_names;
9295         TALLOC_CTX *_mem_save_previous_names_0;
9296         uint32_t _ptr_manufacturer_name;
9297         TALLOC_CTX *_mem_save_manufacturer_name_0;
9298         uint32_t _ptr_manufacturer_url;
9299         TALLOC_CTX *_mem_save_manufacturer_url_0;
9300         uint32_t _ptr_hardware_id;
9301         TALLOC_CTX *_mem_save_hardware_id_0;
9302         uint32_t _ptr_provider;
9303         TALLOC_CTX *_mem_save_provider_0;
9304         if (ndr_flags & NDR_SCALARS) {
9305                 NDR_CHECK(ndr_pull_align(ndr, 8));
9306                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9307                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9308                 if (_ptr_driver_name) {
9309                         NDR_PULL_ALLOC(ndr, r->driver_name);
9310                 } else {
9311                         r->driver_name = NULL;
9312                 }
9313                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9314                 if (_ptr_architecture) {
9315                         NDR_PULL_ALLOC(ndr, r->architecture);
9316                 } else {
9317                         r->architecture = NULL;
9318                 }
9319                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9320                 if (_ptr_driver_path) {
9321                         NDR_PULL_ALLOC(ndr, r->driver_path);
9322                 } else {
9323                         r->driver_path = NULL;
9324                 }
9325                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9326                 if (_ptr_data_file) {
9327                         NDR_PULL_ALLOC(ndr, r->data_file);
9328                 } else {
9329                         r->data_file = NULL;
9330                 }
9331                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9332                 if (_ptr_config_file) {
9333                         NDR_PULL_ALLOC(ndr, r->config_file);
9334                 } else {
9335                         r->config_file = NULL;
9336                 }
9337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9338                 if (_ptr_help_file) {
9339                         NDR_PULL_ALLOC(ndr, r->help_file);
9340                 } else {
9341                         r->help_file = NULL;
9342                 }
9343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9344                 if (_ptr_monitor_name) {
9345                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9346                 } else {
9347                         r->monitor_name = NULL;
9348                 }
9349                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9350                 if (_ptr_default_datatype) {
9351                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9352                 } else {
9353                         r->default_datatype = NULL;
9354                 }
9355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9357                 if (_ptr_dependent_files) {
9358                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9359                 } else {
9360                         r->dependent_files = NULL;
9361                 }
9362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9363                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9364                 if (_ptr_previous_names) {
9365                         NDR_PULL_ALLOC(ndr, r->previous_names);
9366                 } else {
9367                         r->previous_names = NULL;
9368                 }
9369                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9370                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9372                 if (_ptr_manufacturer_name) {
9373                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9374                 } else {
9375                         r->manufacturer_name = NULL;
9376                 }
9377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9378                 if (_ptr_manufacturer_url) {
9379                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9380                 } else {
9381                         r->manufacturer_url = NULL;
9382                 }
9383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9384                 if (_ptr_hardware_id) {
9385                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9386                 } else {
9387                         r->hardware_id = NULL;
9388                 }
9389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9390                 if (_ptr_provider) {
9391                         NDR_PULL_ALLOC(ndr, r->provider);
9392                 } else {
9393                         r->provider = NULL;
9394                 }
9395                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9396         }
9397         if (ndr_flags & NDR_BUFFERS) {
9398                 if (r->driver_name) {
9399                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9400                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9402                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9403                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9404                                 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));
9405                         }
9406                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9407                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9409                 }
9410                 if (r->architecture) {
9411                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9412                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9413                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9414                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9415                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9416                                 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));
9417                         }
9418                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9419                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9421                 }
9422                 if (r->driver_path) {
9423                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9424                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9427                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9428                                 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));
9429                         }
9430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9433                 }
9434                 if (r->data_file) {
9435                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9436                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9438                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9439                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9440                                 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));
9441                         }
9442                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9445                 }
9446                 if (r->config_file) {
9447                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9448                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9450                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9451                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9452                                 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));
9453                         }
9454                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9455                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9457                 }
9458                 if (r->help_file) {
9459                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9460                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9463                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9464                                 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));
9465                         }
9466                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9467                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9469                 }
9470                 if (r->monitor_name) {
9471                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9472                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9475                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9476                                 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));
9477                         }
9478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9479                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9481                 }
9482                 if (r->default_datatype) {
9483                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9484                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9486                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9487                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9488                                 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));
9489                         }
9490                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9491                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9493                 }
9494                 if (r->dependent_files) {
9495                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9496                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9497                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9499                 }
9500                 if (r->previous_names) {
9501                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9502                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9503                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9505                 }
9506                 if (r->manufacturer_name) {
9507                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9508                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9511                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9512                                 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));
9513                         }
9514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9517                 }
9518                 if (r->manufacturer_url) {
9519                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9520                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9521                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9522                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9523                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9524                                 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));
9525                         }
9526                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9527                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9529                 }
9530                 if (r->hardware_id) {
9531                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9532                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9533                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9534                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9535                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9536                                 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));
9537                         }
9538                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9539                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9541                 }
9542                 if (r->provider) {
9543                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9544                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9545                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9546                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9547                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9548                                 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));
9549                         }
9550                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9551                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9552                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9553                 }
9554         }
9555         return NDR_ERR_SUCCESS;
9556 }
9557
9558 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9559 {
9560         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9561         ndr->depth++;
9562         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9563         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9564         ndr->depth++;
9565         if (r->driver_name) {
9566                 ndr_print_string(ndr, "driver_name", r->driver_name);
9567         }
9568         ndr->depth--;
9569         ndr_print_ptr(ndr, "architecture", r->architecture);
9570         ndr->depth++;
9571         if (r->architecture) {
9572                 ndr_print_string(ndr, "architecture", r->architecture);
9573         }
9574         ndr->depth--;
9575         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9576         ndr->depth++;
9577         if (r->driver_path) {
9578                 ndr_print_string(ndr, "driver_path", r->driver_path);
9579         }
9580         ndr->depth--;
9581         ndr_print_ptr(ndr, "data_file", r->data_file);
9582         ndr->depth++;
9583         if (r->data_file) {
9584                 ndr_print_string(ndr, "data_file", r->data_file);
9585         }
9586         ndr->depth--;
9587         ndr_print_ptr(ndr, "config_file", r->config_file);
9588         ndr->depth++;
9589         if (r->config_file) {
9590                 ndr_print_string(ndr, "config_file", r->config_file);
9591         }
9592         ndr->depth--;
9593         ndr_print_ptr(ndr, "help_file", r->help_file);
9594         ndr->depth++;
9595         if (r->help_file) {
9596                 ndr_print_string(ndr, "help_file", r->help_file);
9597         }
9598         ndr->depth--;
9599         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9600         ndr->depth++;
9601         if (r->monitor_name) {
9602                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9603         }
9604         ndr->depth--;
9605         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9606         ndr->depth++;
9607         if (r->default_datatype) {
9608                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9609         }
9610         ndr->depth--;
9611         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);
9612         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9613         ndr->depth++;
9614         if (r->dependent_files) {
9615                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9616         }
9617         ndr->depth--;
9618         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);
9619         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9620         ndr->depth++;
9621         if (r->previous_names) {
9622                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9623         }
9624         ndr->depth--;
9625         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9626         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9627         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9628         ndr->depth++;
9629         if (r->manufacturer_name) {
9630                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9631         }
9632         ndr->depth--;
9633         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9634         ndr->depth++;
9635         if (r->manufacturer_url) {
9636                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9637         }
9638         ndr->depth--;
9639         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9640         ndr->depth++;
9641         if (r->hardware_id) {
9642                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9643         }
9644         ndr->depth--;
9645         ndr_print_ptr(ndr, "provider", r->provider);
9646         ndr->depth++;
9647         if (r->provider) {
9648                 ndr_print_string(ndr, "provider", r->provider);
9649         }
9650         ndr->depth--;
9651         ndr->depth--;
9652 }
9653
9654 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9655 {
9656         if (ndr_flags & NDR_SCALARS) {
9657                 NDR_CHECK(ndr_push_align(ndr, 8));
9658                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9661                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9671                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9672                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9685                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9686                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9687                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9688         }
9689         if (ndr_flags & NDR_BUFFERS) {
9690                 if (r->driver_name) {
9691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9695                 }
9696                 if (r->architecture) {
9697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9700                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9701                 }
9702                 if (r->driver_path) {
9703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9706                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9707                 }
9708                 if (r->data_file) {
9709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9713                 }
9714                 if (r->config_file) {
9715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9718                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9719                 }
9720                 if (r->help_file) {
9721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9725                 }
9726                 if (r->monitor_name) {
9727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9731                 }
9732                 if (r->default_datatype) {
9733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9737                 }
9738                 if (r->dependent_files) {
9739                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9740                 }
9741                 if (r->previous_names) {
9742                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9743                 }
9744                 if (r->manufacturer_name) {
9745                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9747                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9749                 }
9750                 if (r->manufacturer_url) {
9751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9755                 }
9756                 if (r->hardware_id) {
9757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9761                 }
9762                 if (r->provider) {
9763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9766                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9767                 }
9768                 if (r->print_processor) {
9769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9772                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9773                 }
9774                 if (r->vendor_setup) {
9775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9778                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9779                 }
9780                 if (r->color_profiles) {
9781                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9782                 }
9783                 if (r->inf_path) {
9784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9787                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9788                 }
9789                 if (r->core_driver_dependencies) {
9790                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9791                 }
9792         }
9793         return NDR_ERR_SUCCESS;
9794 }
9795
9796 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9797 {
9798         uint32_t _ptr_driver_name;
9799         TALLOC_CTX *_mem_save_driver_name_0;
9800         uint32_t _ptr_architecture;
9801         TALLOC_CTX *_mem_save_architecture_0;
9802         uint32_t _ptr_driver_path;
9803         TALLOC_CTX *_mem_save_driver_path_0;
9804         uint32_t _ptr_data_file;
9805         TALLOC_CTX *_mem_save_data_file_0;
9806         uint32_t _ptr_config_file;
9807         TALLOC_CTX *_mem_save_config_file_0;
9808         uint32_t _ptr_help_file;
9809         TALLOC_CTX *_mem_save_help_file_0;
9810         uint32_t _ptr_monitor_name;
9811         TALLOC_CTX *_mem_save_monitor_name_0;
9812         uint32_t _ptr_default_datatype;
9813         TALLOC_CTX *_mem_save_default_datatype_0;
9814         uint32_t _ptr_dependent_files;
9815         TALLOC_CTX *_mem_save_dependent_files_0;
9816         uint32_t _ptr_previous_names;
9817         TALLOC_CTX *_mem_save_previous_names_0;
9818         uint32_t _ptr_manufacturer_name;
9819         TALLOC_CTX *_mem_save_manufacturer_name_0;
9820         uint32_t _ptr_manufacturer_url;
9821         TALLOC_CTX *_mem_save_manufacturer_url_0;
9822         uint32_t _ptr_hardware_id;
9823         TALLOC_CTX *_mem_save_hardware_id_0;
9824         uint32_t _ptr_provider;
9825         TALLOC_CTX *_mem_save_provider_0;
9826         uint32_t _ptr_print_processor;
9827         TALLOC_CTX *_mem_save_print_processor_0;
9828         uint32_t _ptr_vendor_setup;
9829         TALLOC_CTX *_mem_save_vendor_setup_0;
9830         uint32_t _ptr_color_profiles;
9831         TALLOC_CTX *_mem_save_color_profiles_0;
9832         uint32_t _ptr_inf_path;
9833         TALLOC_CTX *_mem_save_inf_path_0;
9834         uint32_t _ptr_core_driver_dependencies;
9835         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9836         if (ndr_flags & NDR_SCALARS) {
9837                 NDR_CHECK(ndr_pull_align(ndr, 8));
9838                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9840                 if (_ptr_driver_name) {
9841                         NDR_PULL_ALLOC(ndr, r->driver_name);
9842                 } else {
9843                         r->driver_name = NULL;
9844                 }
9845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9846                 if (_ptr_architecture) {
9847                         NDR_PULL_ALLOC(ndr, r->architecture);
9848                 } else {
9849                         r->architecture = NULL;
9850                 }
9851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9852                 if (_ptr_driver_path) {
9853                         NDR_PULL_ALLOC(ndr, r->driver_path);
9854                 } else {
9855                         r->driver_path = NULL;
9856                 }
9857                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9858                 if (_ptr_data_file) {
9859                         NDR_PULL_ALLOC(ndr, r->data_file);
9860                 } else {
9861                         r->data_file = NULL;
9862                 }
9863                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9864                 if (_ptr_config_file) {
9865                         NDR_PULL_ALLOC(ndr, r->config_file);
9866                 } else {
9867                         r->config_file = NULL;
9868                 }
9869                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9870                 if (_ptr_help_file) {
9871                         NDR_PULL_ALLOC(ndr, r->help_file);
9872                 } else {
9873                         r->help_file = NULL;
9874                 }
9875                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9876                 if (_ptr_monitor_name) {
9877                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9878                 } else {
9879                         r->monitor_name = NULL;
9880                 }
9881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9882                 if (_ptr_default_datatype) {
9883                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9884                 } else {
9885                         r->default_datatype = NULL;
9886                 }
9887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9889                 if (_ptr_dependent_files) {
9890                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9891                 } else {
9892                         r->dependent_files = NULL;
9893                 }
9894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9896                 if (_ptr_previous_names) {
9897                         NDR_PULL_ALLOC(ndr, r->previous_names);
9898                 } else {
9899                         r->previous_names = NULL;
9900                 }
9901                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9902                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9904                 if (_ptr_manufacturer_name) {
9905                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9906                 } else {
9907                         r->manufacturer_name = NULL;
9908                 }
9909                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9910                 if (_ptr_manufacturer_url) {
9911                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9912                 } else {
9913                         r->manufacturer_url = NULL;
9914                 }
9915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9916                 if (_ptr_hardware_id) {
9917                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9918                 } else {
9919                         r->hardware_id = NULL;
9920                 }
9921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9922                 if (_ptr_provider) {
9923                         NDR_PULL_ALLOC(ndr, r->provider);
9924                 } else {
9925                         r->provider = NULL;
9926                 }
9927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9928                 if (_ptr_print_processor) {
9929                         NDR_PULL_ALLOC(ndr, r->print_processor);
9930                 } else {
9931                         r->print_processor = NULL;
9932                 }
9933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9934                 if (_ptr_vendor_setup) {
9935                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9936                 } else {
9937                         r->vendor_setup = NULL;
9938                 }
9939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9941                 if (_ptr_color_profiles) {
9942                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9943                 } else {
9944                         r->color_profiles = NULL;
9945                 }
9946                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9947                 if (_ptr_inf_path) {
9948                         NDR_PULL_ALLOC(ndr, r->inf_path);
9949                 } else {
9950                         r->inf_path = NULL;
9951                 }
9952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9955                 if (_ptr_core_driver_dependencies) {
9956                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9957                 } else {
9958                         r->core_driver_dependencies = NULL;
9959                 }
9960                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9961                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9962                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9963         }
9964         if (ndr_flags & NDR_BUFFERS) {
9965                 if (r->driver_name) {
9966                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9967                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9970                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9971                                 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));
9972                         }
9973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9976                 }
9977                 if (r->architecture) {
9978                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9979                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9982                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9983                                 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));
9984                         }
9985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9988                 }
9989                 if (r->driver_path) {
9990                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9991                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9994                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9995                                 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));
9996                         }
9997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10000                 }
10001                 if (r->data_file) {
10002                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10003                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10004                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
10005                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
10006                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
10007                                 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));
10008                         }
10009                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
10010                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
10011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10012                 }
10013                 if (r->config_file) {
10014                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10015                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
10017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
10018                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
10019                                 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));
10020                         }
10021                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
10022                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
10023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10024                 }
10025                 if (r->help_file) {
10026                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10027                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10028                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
10029                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
10030                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
10031                                 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));
10032                         }
10033                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
10034                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
10035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10036                 }
10037                 if (r->monitor_name) {
10038                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10039                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10040                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
10041                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
10042                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
10043                                 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));
10044                         }
10045                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
10046                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
10047                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10048                 }
10049                 if (r->default_datatype) {
10050                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10051                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10052                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
10053                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
10054                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
10055                                 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));
10056                         }
10057                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10058                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10060                 }
10061                 if (r->dependent_files) {
10062                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10063                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10064                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10066                 }
10067                 if (r->previous_names) {
10068                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10069                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10070                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10072                 }
10073                 if (r->manufacturer_name) {
10074                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10075                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10076                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10077                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10078                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10079                                 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));
10080                         }
10081                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10082                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10084                 }
10085                 if (r->manufacturer_url) {
10086                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10087                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10090                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10091                                 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));
10092                         }
10093                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10094                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10096                 }
10097                 if (r->hardware_id) {
10098                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10099                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10102                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10103                                 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));
10104                         }
10105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10106                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10108                 }
10109                 if (r->provider) {
10110                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10111                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10112                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10113                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10114                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10115                                 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));
10116                         }
10117                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10118                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10120                 }
10121                 if (r->print_processor) {
10122                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10123                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10124                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10125                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10126                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10127                                 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));
10128                         }
10129                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10130                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10132                 }
10133                 if (r->vendor_setup) {
10134                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10135                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10136                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10137                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10138                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10139                                 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));
10140                         }
10141                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10142                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10144                 }
10145                 if (r->color_profiles) {
10146                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10147                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10148                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10150                 }
10151                 if (r->inf_path) {
10152                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10153                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10156                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10157                                 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));
10158                         }
10159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10162                 }
10163                 if (r->core_driver_dependencies) {
10164                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10165                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10166                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10168                 }
10169         }
10170         return NDR_ERR_SUCCESS;
10171 }
10172
10173 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10174 {
10175         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10176         ndr->depth++;
10177         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10178         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10179         ndr->depth++;
10180         if (r->driver_name) {
10181                 ndr_print_string(ndr, "driver_name", r->driver_name);
10182         }
10183         ndr->depth--;
10184         ndr_print_ptr(ndr, "architecture", r->architecture);
10185         ndr->depth++;
10186         if (r->architecture) {
10187                 ndr_print_string(ndr, "architecture", r->architecture);
10188         }
10189         ndr->depth--;
10190         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10191         ndr->depth++;
10192         if (r->driver_path) {
10193                 ndr_print_string(ndr, "driver_path", r->driver_path);
10194         }
10195         ndr->depth--;
10196         ndr_print_ptr(ndr, "data_file", r->data_file);
10197         ndr->depth++;
10198         if (r->data_file) {
10199                 ndr_print_string(ndr, "data_file", r->data_file);
10200         }
10201         ndr->depth--;
10202         ndr_print_ptr(ndr, "config_file", r->config_file);
10203         ndr->depth++;
10204         if (r->config_file) {
10205                 ndr_print_string(ndr, "config_file", r->config_file);
10206         }
10207         ndr->depth--;
10208         ndr_print_ptr(ndr, "help_file", r->help_file);
10209         ndr->depth++;
10210         if (r->help_file) {
10211                 ndr_print_string(ndr, "help_file", r->help_file);
10212         }
10213         ndr->depth--;
10214         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10215         ndr->depth++;
10216         if (r->monitor_name) {
10217                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10218         }
10219         ndr->depth--;
10220         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10221         ndr->depth++;
10222         if (r->default_datatype) {
10223                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10224         }
10225         ndr->depth--;
10226         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);
10227         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10228         ndr->depth++;
10229         if (r->dependent_files) {
10230                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10231         }
10232         ndr->depth--;
10233         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);
10234         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10235         ndr->depth++;
10236         if (r->previous_names) {
10237                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10238         }
10239         ndr->depth--;
10240         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10241         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10242         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10243         ndr->depth++;
10244         if (r->manufacturer_name) {
10245                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10246         }
10247         ndr->depth--;
10248         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10249         ndr->depth++;
10250         if (r->manufacturer_url) {
10251                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10252         }
10253         ndr->depth--;
10254         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10255         ndr->depth++;
10256         if (r->hardware_id) {
10257                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10258         }
10259         ndr->depth--;
10260         ndr_print_ptr(ndr, "provider", r->provider);
10261         ndr->depth++;
10262         if (r->provider) {
10263                 ndr_print_string(ndr, "provider", r->provider);
10264         }
10265         ndr->depth--;
10266         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10267         ndr->depth++;
10268         if (r->print_processor) {
10269                 ndr_print_string(ndr, "print_processor", r->print_processor);
10270         }
10271         ndr->depth--;
10272         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10273         ndr->depth++;
10274         if (r->vendor_setup) {
10275                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10276         }
10277         ndr->depth--;
10278         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);
10279         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10280         ndr->depth++;
10281         if (r->color_profiles) {
10282                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10283         }
10284         ndr->depth--;
10285         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10286         ndr->depth++;
10287         if (r->inf_path) {
10288                 ndr_print_string(ndr, "inf_path", r->inf_path);
10289         }
10290         ndr->depth--;
10291         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10292         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);
10293         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10294         ndr->depth++;
10295         if (r->core_driver_dependencies) {
10296                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10297         }
10298         ndr->depth--;
10299         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10300         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10301         ndr->depth--;
10302 }
10303
10304 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10305 {
10306         if (ndr_flags & NDR_SCALARS) {
10307                 int level = ndr_push_get_switch_value(ndr, r);
10308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10309                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10310                 switch (level) {
10311                         case 1: {
10312                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10313                         break; }
10314
10315                         case 2: {
10316                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10317                         break; }
10318
10319                         case 3: {
10320                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10321                         break; }
10322
10323                         case 4: {
10324                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10325                         break; }
10326
10327                         case 6: {
10328                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10329                         break; }
10330
10331                         case 8: {
10332                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10333                         break; }
10334
10335                         default:
10336                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10337                 }
10338         }
10339         if (ndr_flags & NDR_BUFFERS) {
10340                 int level = ndr_push_get_switch_value(ndr, r);
10341                 switch (level) {
10342                         case 1:
10343                                 if (r->info1) {
10344                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10345                                 }
10346                         break;
10347
10348                         case 2:
10349                                 if (r->info2) {
10350                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10351                                 }
10352                         break;
10353
10354                         case 3:
10355                                 if (r->info3) {
10356                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10357                                 }
10358                         break;
10359
10360                         case 4:
10361                                 if (r->info4) {
10362                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10363                                 }
10364                         break;
10365
10366                         case 6:
10367                                 if (r->info6) {
10368                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10369                                 }
10370                         break;
10371
10372                         case 8:
10373                                 if (r->info8) {
10374                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10375                                 }
10376                         break;
10377
10378                         default:
10379                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10380                 }
10381         }
10382         return NDR_ERR_SUCCESS;
10383 }
10384
10385 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10386 {
10387         int level;
10388         uint32_t _level;
10389         TALLOC_CTX *_mem_save_info1_0;
10390         TALLOC_CTX *_mem_save_info2_0;
10391         TALLOC_CTX *_mem_save_info3_0;
10392         TALLOC_CTX *_mem_save_info4_0;
10393         TALLOC_CTX *_mem_save_info6_0;
10394         TALLOC_CTX *_mem_save_info8_0;
10395         level = ndr_pull_get_switch_value(ndr, r);
10396         if (ndr_flags & NDR_SCALARS) {
10397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10398                 if (_level != level) {
10399                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10400                 }
10401                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10402                 switch (level) {
10403                         case 1: {
10404                                 uint32_t _ptr_info1;
10405                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10406                                 if (_ptr_info1) {
10407                                         NDR_PULL_ALLOC(ndr, r->info1);
10408                                 } else {
10409                                         r->info1 = NULL;
10410                                 }
10411                         break; }
10412
10413                         case 2: {
10414                                 uint32_t _ptr_info2;
10415                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10416                                 if (_ptr_info2) {
10417                                         NDR_PULL_ALLOC(ndr, r->info2);
10418                                 } else {
10419                                         r->info2 = NULL;
10420                                 }
10421                         break; }
10422
10423                         case 3: {
10424                                 uint32_t _ptr_info3;
10425                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10426                                 if (_ptr_info3) {
10427                                         NDR_PULL_ALLOC(ndr, r->info3);
10428                                 } else {
10429                                         r->info3 = NULL;
10430                                 }
10431                         break; }
10432
10433                         case 4: {
10434                                 uint32_t _ptr_info4;
10435                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10436                                 if (_ptr_info4) {
10437                                         NDR_PULL_ALLOC(ndr, r->info4);
10438                                 } else {
10439                                         r->info4 = NULL;
10440                                 }
10441                         break; }
10442
10443                         case 6: {
10444                                 uint32_t _ptr_info6;
10445                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10446                                 if (_ptr_info6) {
10447                                         NDR_PULL_ALLOC(ndr, r->info6);
10448                                 } else {
10449                                         r->info6 = NULL;
10450                                 }
10451                         break; }
10452
10453                         case 8: {
10454                                 uint32_t _ptr_info8;
10455                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10456                                 if (_ptr_info8) {
10457                                         NDR_PULL_ALLOC(ndr, r->info8);
10458                                 } else {
10459                                         r->info8 = NULL;
10460                                 }
10461                         break; }
10462
10463                         default:
10464                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10465                 }
10466         }
10467         if (ndr_flags & NDR_BUFFERS) {
10468                 switch (level) {
10469                         case 1:
10470                                 if (r->info1) {
10471                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10472                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10473                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10474                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10475                                 }
10476                         break;
10477
10478                         case 2:
10479                                 if (r->info2) {
10480                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10482                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10483                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10484                                 }
10485                         break;
10486
10487                         case 3:
10488                                 if (r->info3) {
10489                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10490                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10491                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10492                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10493                                 }
10494                         break;
10495
10496                         case 4:
10497                                 if (r->info4) {
10498                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10499                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10500                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10501                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10502                                 }
10503                         break;
10504
10505                         case 6:
10506                                 if (r->info6) {
10507                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10508                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10509                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10510                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10511                                 }
10512                         break;
10513
10514                         case 8:
10515                                 if (r->info8) {
10516                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10517                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10518                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10519                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10520                                 }
10521                         break;
10522
10523                         default:
10524                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10525                 }
10526         }
10527         return NDR_ERR_SUCCESS;
10528 }
10529
10530 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10531 {
10532         int level;
10533         level = ndr_print_get_switch_value(ndr, r);
10534         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10535         switch (level) {
10536                 case 1:
10537                         ndr_print_ptr(ndr, "info1", r->info1);
10538                         ndr->depth++;
10539                         if (r->info1) {
10540                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10541                         }
10542                         ndr->depth--;
10543                 break;
10544
10545                 case 2:
10546                         ndr_print_ptr(ndr, "info2", r->info2);
10547                         ndr->depth++;
10548                         if (r->info2) {
10549                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10550                         }
10551                         ndr->depth--;
10552                 break;
10553
10554                 case 3:
10555                         ndr_print_ptr(ndr, "info3", r->info3);
10556                         ndr->depth++;
10557                         if (r->info3) {
10558                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10559                         }
10560                         ndr->depth--;
10561                 break;
10562
10563                 case 4:
10564                         ndr_print_ptr(ndr, "info4", r->info4);
10565                         ndr->depth++;
10566                         if (r->info4) {
10567                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10568                         }
10569                         ndr->depth--;
10570                 break;
10571
10572                 case 6:
10573                         ndr_print_ptr(ndr, "info6", r->info6);
10574                         ndr->depth++;
10575                         if (r->info6) {
10576                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10577                         }
10578                         ndr->depth--;
10579                 break;
10580
10581                 case 8:
10582                         ndr_print_ptr(ndr, "info8", r->info8);
10583                         ndr->depth++;
10584                         if (r->info8) {
10585                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10586                         }
10587                         ndr->depth--;
10588                 break;
10589
10590                 default:
10591                         ndr_print_bad_level(ndr, name, level);
10592         }
10593 }
10594
10595 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10596 {
10597         if (ndr_flags & NDR_SCALARS) {
10598                 NDR_CHECK(ndr_push_align(ndr, 5));
10599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10600                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10601                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10602                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10603         }
10604         if (ndr_flags & NDR_BUFFERS) {
10605                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10606         }
10607         return NDR_ERR_SUCCESS;
10608 }
10609
10610 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10611 {
10612         if (ndr_flags & NDR_SCALARS) {
10613                 NDR_CHECK(ndr_pull_align(ndr, 5));
10614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10615                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10616                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10617                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10618         }
10619         if (ndr_flags & NDR_BUFFERS) {
10620                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10621         }
10622         return NDR_ERR_SUCCESS;
10623 }
10624
10625 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10626 {
10627         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10628         ndr->depth++;
10629         ndr_print_uint32(ndr, "level", r->level);
10630         ndr_print_set_switch_value(ndr, &r->info, r->level);
10631         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10632         ndr->depth--;
10633 }
10634
10635 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10636 {
10637         if (ndr_flags & NDR_SCALARS) {
10638                 NDR_CHECK(ndr_push_align(ndr, 5));
10639                 {
10640                         uint32_t _flags_save_string = ndr->flags;
10641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10642                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10643                         ndr->flags = _flags_save_string;
10644                 }
10645                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10646         }
10647         if (ndr_flags & NDR_BUFFERS) {
10648                 {
10649                         uint32_t _flags_save_string = ndr->flags;
10650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10651                         if (r->driver_name) {
10652                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10653                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10654                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10655                         }
10656                         ndr->flags = _flags_save_string;
10657                 }
10658         }
10659         return NDR_ERR_SUCCESS;
10660 }
10661
10662 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10663 {
10664         uint32_t _ptr_driver_name;
10665         TALLOC_CTX *_mem_save_driver_name_0;
10666         if (ndr_flags & NDR_SCALARS) {
10667                 NDR_CHECK(ndr_pull_align(ndr, 5));
10668                 {
10669                         uint32_t _flags_save_string = ndr->flags;
10670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10671                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10672                         if (_ptr_driver_name) {
10673                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10674                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10675                         } else {
10676                                 r->driver_name = NULL;
10677                         }
10678                         ndr->flags = _flags_save_string;
10679                 }
10680                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10681         }
10682         if (ndr_flags & NDR_BUFFERS) {
10683                 {
10684                         uint32_t _flags_save_string = ndr->flags;
10685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10686                         if (r->driver_name) {
10687                                 uint32_t _relative_save_offset;
10688                                 _relative_save_offset = ndr->offset;
10689                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10690                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10691                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10692                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10693                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10694                                 if (ndr->offset > ndr->relative_highest_offset) {
10695                                         ndr->relative_highest_offset = ndr->offset;
10696                                 }
10697                                 ndr->offset = _relative_save_offset;
10698                         }
10699                         ndr->flags = _flags_save_string;
10700                 }
10701         }
10702         return NDR_ERR_SUCCESS;
10703 }
10704
10705 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10706 {
10707         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10708         ndr->depth++;
10709         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10710         ndr->depth++;
10711         if (r->driver_name) {
10712                 ndr_print_string(ndr, "driver_name", r->driver_name);
10713         }
10714         ndr->depth--;
10715         ndr->depth--;
10716 }
10717
10718 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10719 {
10720         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10721 }
10722
10723 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10724 {
10725         if (ndr_flags & NDR_SCALARS) {
10726                 NDR_CHECK(ndr_push_align(ndr, 5));
10727                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10728                 {
10729                         uint32_t _flags_save_string = ndr->flags;
10730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10731                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10732                         ndr->flags = _flags_save_string;
10733                 }
10734                 {
10735                         uint32_t _flags_save_string = ndr->flags;
10736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10737                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10738                         ndr->flags = _flags_save_string;
10739                 }
10740                 {
10741                         uint32_t _flags_save_string = ndr->flags;
10742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10743                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10744                         ndr->flags = _flags_save_string;
10745                 }
10746                 {
10747                         uint32_t _flags_save_string = ndr->flags;
10748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10750                         ndr->flags = _flags_save_string;
10751                 }
10752                 {
10753                         uint32_t _flags_save_string = ndr->flags;
10754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10755                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10756                         ndr->flags = _flags_save_string;
10757                 }
10758                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10759         }
10760         if (ndr_flags & NDR_BUFFERS) {
10761                 {
10762                         uint32_t _flags_save_string = ndr->flags;
10763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10764                         if (r->driver_name) {
10765                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10766                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10767                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10768                         }
10769                         ndr->flags = _flags_save_string;
10770                 }
10771                 {
10772                         uint32_t _flags_save_string = ndr->flags;
10773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10774                         if (r->architecture) {
10775                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
10776                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10777                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
10778                         }
10779                         ndr->flags = _flags_save_string;
10780                 }
10781                 {
10782                         uint32_t _flags_save_string = ndr->flags;
10783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10784                         if (r->driver_path) {
10785                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
10786                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10787                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
10788                         }
10789                         ndr->flags = _flags_save_string;
10790                 }
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         if (r->data_file) {
10795                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
10796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10797                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
10798                         }
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                         if (r->config_file) {
10805                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
10806                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10807                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
10808                         }
10809                         ndr->flags = _flags_save_string;
10810                 }
10811         }
10812         return NDR_ERR_SUCCESS;
10813 }
10814
10815 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10816 {
10817         uint32_t _ptr_driver_name;
10818         TALLOC_CTX *_mem_save_driver_name_0;
10819         uint32_t _ptr_architecture;
10820         TALLOC_CTX *_mem_save_architecture_0;
10821         uint32_t _ptr_driver_path;
10822         TALLOC_CTX *_mem_save_driver_path_0;
10823         uint32_t _ptr_data_file;
10824         TALLOC_CTX *_mem_save_data_file_0;
10825         uint32_t _ptr_config_file;
10826         TALLOC_CTX *_mem_save_config_file_0;
10827         if (ndr_flags & NDR_SCALARS) {
10828                 NDR_CHECK(ndr_pull_align(ndr, 5));
10829                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10830                 {
10831                         uint32_t _flags_save_string = ndr->flags;
10832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10834                         if (_ptr_driver_name) {
10835                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10837                         } else {
10838                                 r->driver_name = NULL;
10839                         }
10840                         ndr->flags = _flags_save_string;
10841                 }
10842                 {
10843                         uint32_t _flags_save_string = ndr->flags;
10844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10845                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10846                         if (_ptr_architecture) {
10847                                 NDR_PULL_ALLOC(ndr, r->architecture);
10848                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10849                         } else {
10850                                 r->architecture = NULL;
10851                         }
10852                         ndr->flags = _flags_save_string;
10853                 }
10854                 {
10855                         uint32_t _flags_save_string = ndr->flags;
10856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10857                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10858                         if (_ptr_driver_path) {
10859                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10860                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10861                         } else {
10862                                 r->driver_path = NULL;
10863                         }
10864                         ndr->flags = _flags_save_string;
10865                 }
10866                 {
10867                         uint32_t _flags_save_string = ndr->flags;
10868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10869                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10870                         if (_ptr_data_file) {
10871                                 NDR_PULL_ALLOC(ndr, r->data_file);
10872                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10873                         } else {
10874                                 r->data_file = NULL;
10875                         }
10876                         ndr->flags = _flags_save_string;
10877                 }
10878                 {
10879                         uint32_t _flags_save_string = ndr->flags;
10880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10881                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10882                         if (_ptr_config_file) {
10883                                 NDR_PULL_ALLOC(ndr, r->config_file);
10884                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10885                         } else {
10886                                 r->config_file = NULL;
10887                         }
10888                         ndr->flags = _flags_save_string;
10889                 }
10890                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10891         }
10892         if (ndr_flags & NDR_BUFFERS) {
10893                 {
10894                         uint32_t _flags_save_string = ndr->flags;
10895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10896                         if (r->driver_name) {
10897                                 uint32_t _relative_save_offset;
10898                                 _relative_save_offset = ndr->offset;
10899                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10900                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10901                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10902                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10903                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10904                                 if (ndr->offset > ndr->relative_highest_offset) {
10905                                         ndr->relative_highest_offset = ndr->offset;
10906                                 }
10907                                 ndr->offset = _relative_save_offset;
10908                         }
10909                         ndr->flags = _flags_save_string;
10910                 }
10911                 {
10912                         uint32_t _flags_save_string = ndr->flags;
10913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10914                         if (r->architecture) {
10915                                 uint32_t _relative_save_offset;
10916                                 _relative_save_offset = ndr->offset;
10917                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10918                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10919                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10920                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10921                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10922                                 if (ndr->offset > ndr->relative_highest_offset) {
10923                                         ndr->relative_highest_offset = ndr->offset;
10924                                 }
10925                                 ndr->offset = _relative_save_offset;
10926                         }
10927                         ndr->flags = _flags_save_string;
10928                 }
10929                 {
10930                         uint32_t _flags_save_string = ndr->flags;
10931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10932                         if (r->driver_path) {
10933                                 uint32_t _relative_save_offset;
10934                                 _relative_save_offset = ndr->offset;
10935                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10936                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10937                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10938                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10939                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10940                                 if (ndr->offset > ndr->relative_highest_offset) {
10941                                         ndr->relative_highest_offset = ndr->offset;
10942                                 }
10943                                 ndr->offset = _relative_save_offset;
10944                         }
10945                         ndr->flags = _flags_save_string;
10946                 }
10947                 {
10948                         uint32_t _flags_save_string = ndr->flags;
10949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10950                         if (r->data_file) {
10951                                 uint32_t _relative_save_offset;
10952                                 _relative_save_offset = ndr->offset;
10953                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10954                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10955                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10956                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10957                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10958                                 if (ndr->offset > ndr->relative_highest_offset) {
10959                                         ndr->relative_highest_offset = ndr->offset;
10960                                 }
10961                                 ndr->offset = _relative_save_offset;
10962                         }
10963                         ndr->flags = _flags_save_string;
10964                 }
10965                 {
10966                         uint32_t _flags_save_string = ndr->flags;
10967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10968                         if (r->config_file) {
10969                                 uint32_t _relative_save_offset;
10970                                 _relative_save_offset = ndr->offset;
10971                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10972                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10973                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10974                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10975                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10976                                 if (ndr->offset > ndr->relative_highest_offset) {
10977                                         ndr->relative_highest_offset = ndr->offset;
10978                                 }
10979                                 ndr->offset = _relative_save_offset;
10980                         }
10981                         ndr->flags = _flags_save_string;
10982                 }
10983         }
10984         return NDR_ERR_SUCCESS;
10985 }
10986
10987 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10988 {
10989         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10990         ndr->depth++;
10991         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10992         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10993         ndr->depth++;
10994         if (r->driver_name) {
10995                 ndr_print_string(ndr, "driver_name", r->driver_name);
10996         }
10997         ndr->depth--;
10998         ndr_print_ptr(ndr, "architecture", r->architecture);
10999         ndr->depth++;
11000         if (r->architecture) {
11001                 ndr_print_string(ndr, "architecture", r->architecture);
11002         }
11003         ndr->depth--;
11004         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11005         ndr->depth++;
11006         if (r->driver_path) {
11007                 ndr_print_string(ndr, "driver_path", r->driver_path);
11008         }
11009         ndr->depth--;
11010         ndr_print_ptr(ndr, "data_file", r->data_file);
11011         ndr->depth++;
11012         if (r->data_file) {
11013                 ndr_print_string(ndr, "data_file", r->data_file);
11014         }
11015         ndr->depth--;
11016         ndr_print_ptr(ndr, "config_file", r->config_file);
11017         ndr->depth++;
11018         if (r->config_file) {
11019                 ndr_print_string(ndr, "config_file", r->config_file);
11020         }
11021         ndr->depth--;
11022         ndr->depth--;
11023 }
11024
11025 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
11026 {
11027         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
11028 }
11029
11030 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
11031 {
11032         if (ndr_flags & NDR_SCALARS) {
11033                 NDR_CHECK(ndr_push_align(ndr, 5));
11034                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11035                 {
11036                         uint32_t _flags_save_string = ndr->flags;
11037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11039                         ndr->flags = _flags_save_string;
11040                 }
11041                 {
11042                         uint32_t _flags_save_string = ndr->flags;
11043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11051                         ndr->flags = _flags_save_string;
11052                 }
11053                 {
11054                         uint32_t _flags_save_string = ndr->flags;
11055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11057                         ndr->flags = _flags_save_string;
11058                 }
11059                 {
11060                         uint32_t _flags_save_string = ndr->flags;
11061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11062                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11063                         ndr->flags = _flags_save_string;
11064                 }
11065                 {
11066                         uint32_t _flags_save_string = ndr->flags;
11067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11068                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11069                         ndr->flags = _flags_save_string;
11070                 }
11071                 {
11072                         uint32_t _flags_save_string_array = ndr->flags;
11073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11074                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11075                         ndr->flags = _flags_save_string_array;
11076                 }
11077                 {
11078                         uint32_t _flags_save_string = ndr->flags;
11079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11080                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11081                         ndr->flags = _flags_save_string;
11082                 }
11083                 {
11084                         uint32_t _flags_save_string = ndr->flags;
11085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11086                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11087                         ndr->flags = _flags_save_string;
11088                 }
11089                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11090         }
11091         if (ndr_flags & NDR_BUFFERS) {
11092                 {
11093                         uint32_t _flags_save_string = ndr->flags;
11094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11095                         if (r->driver_name) {
11096                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11097                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11098                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11099                         }
11100                         ndr->flags = _flags_save_string;
11101                 }
11102                 {
11103                         uint32_t _flags_save_string = ndr->flags;
11104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11105                         if (r->architecture) {
11106                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11107                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11108                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11109                         }
11110                         ndr->flags = _flags_save_string;
11111                 }
11112                 {
11113                         uint32_t _flags_save_string = ndr->flags;
11114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11115                         if (r->driver_path) {
11116                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11117                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11118                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11119                         }
11120                         ndr->flags = _flags_save_string;
11121                 }
11122                 {
11123                         uint32_t _flags_save_string = ndr->flags;
11124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11125                         if (r->data_file) {
11126                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11127                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11128                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11129                         }
11130                         ndr->flags = _flags_save_string;
11131                 }
11132                 {
11133                         uint32_t _flags_save_string = ndr->flags;
11134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11135                         if (r->config_file) {
11136                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11138                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11139                         }
11140                         ndr->flags = _flags_save_string;
11141                 }
11142                 {
11143                         uint32_t _flags_save_string = ndr->flags;
11144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11145                         if (r->help_file) {
11146                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11148                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11149                         }
11150                         ndr->flags = _flags_save_string;
11151                 }
11152                 {
11153                         uint32_t _flags_save_string_array = ndr->flags;
11154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11155                         if (r->dependent_files) {
11156                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11157                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11158                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11159                         }
11160                         ndr->flags = _flags_save_string_array;
11161                 }
11162                 {
11163                         uint32_t _flags_save_string = ndr->flags;
11164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11165                         if (r->monitor_name) {
11166                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11167                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11168                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11169                         }
11170                         ndr->flags = _flags_save_string;
11171                 }
11172                 {
11173                         uint32_t _flags_save_string = ndr->flags;
11174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11175                         if (r->default_datatype) {
11176                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11177                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11178                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11179                         }
11180                         ndr->flags = _flags_save_string;
11181                 }
11182         }
11183         return NDR_ERR_SUCCESS;
11184 }
11185
11186 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11187 {
11188         uint32_t _ptr_driver_name;
11189         TALLOC_CTX *_mem_save_driver_name_0;
11190         uint32_t _ptr_architecture;
11191         TALLOC_CTX *_mem_save_architecture_0;
11192         uint32_t _ptr_driver_path;
11193         TALLOC_CTX *_mem_save_driver_path_0;
11194         uint32_t _ptr_data_file;
11195         TALLOC_CTX *_mem_save_data_file_0;
11196         uint32_t _ptr_config_file;
11197         TALLOC_CTX *_mem_save_config_file_0;
11198         uint32_t _ptr_help_file;
11199         TALLOC_CTX *_mem_save_help_file_0;
11200         uint32_t _ptr_dependent_files;
11201         TALLOC_CTX *_mem_save_dependent_files_0;
11202         uint32_t _ptr_monitor_name;
11203         TALLOC_CTX *_mem_save_monitor_name_0;
11204         uint32_t _ptr_default_datatype;
11205         TALLOC_CTX *_mem_save_default_datatype_0;
11206         if (ndr_flags & NDR_SCALARS) {
11207                 NDR_CHECK(ndr_pull_align(ndr, 5));
11208                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11209                 {
11210                         uint32_t _flags_save_string = ndr->flags;
11211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11212                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11213                         if (_ptr_driver_name) {
11214                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11215                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11216                         } else {
11217                                 r->driver_name = NULL;
11218                         }
11219                         ndr->flags = _flags_save_string;
11220                 }
11221                 {
11222                         uint32_t _flags_save_string = ndr->flags;
11223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11225                         if (_ptr_architecture) {
11226                                 NDR_PULL_ALLOC(ndr, r->architecture);
11227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11228                         } else {
11229                                 r->architecture = NULL;
11230                         }
11231                         ndr->flags = _flags_save_string;
11232                 }
11233                 {
11234                         uint32_t _flags_save_string = ndr->flags;
11235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11237                         if (_ptr_driver_path) {
11238                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11240                         } else {
11241                                 r->driver_path = NULL;
11242                         }
11243                         ndr->flags = _flags_save_string;
11244                 }
11245                 {
11246                         uint32_t _flags_save_string = ndr->flags;
11247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11249                         if (_ptr_data_file) {
11250                                 NDR_PULL_ALLOC(ndr, r->data_file);
11251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11252                         } else {
11253                                 r->data_file = NULL;
11254                         }
11255                         ndr->flags = _flags_save_string;
11256                 }
11257                 {
11258                         uint32_t _flags_save_string = ndr->flags;
11259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11260                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11261                         if (_ptr_config_file) {
11262                                 NDR_PULL_ALLOC(ndr, r->config_file);
11263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11264                         } else {
11265                                 r->config_file = NULL;
11266                         }
11267                         ndr->flags = _flags_save_string;
11268                 }
11269                 {
11270                         uint32_t _flags_save_string = ndr->flags;
11271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11273                         if (_ptr_help_file) {
11274                                 NDR_PULL_ALLOC(ndr, r->help_file);
11275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11276                         } else {
11277                                 r->help_file = NULL;
11278                         }
11279                         ndr->flags = _flags_save_string;
11280                 }
11281                 {
11282                         uint32_t _flags_save_string_array = ndr->flags;
11283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11285                         if (_ptr_dependent_files) {
11286                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11288                         } else {
11289                                 r->dependent_files = NULL;
11290                         }
11291                         ndr->flags = _flags_save_string_array;
11292                 }
11293                 {
11294                         uint32_t _flags_save_string = ndr->flags;
11295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11296                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11297                         if (_ptr_monitor_name) {
11298                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11299                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11300                         } else {
11301                                 r->monitor_name = NULL;
11302                         }
11303                         ndr->flags = _flags_save_string;
11304                 }
11305                 {
11306                         uint32_t _flags_save_string = ndr->flags;
11307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11308                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11309                         if (_ptr_default_datatype) {
11310                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11311                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11312                         } else {
11313                                 r->default_datatype = NULL;
11314                         }
11315                         ndr->flags = _flags_save_string;
11316                 }
11317                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11318         }
11319         if (ndr_flags & NDR_BUFFERS) {
11320                 {
11321                         uint32_t _flags_save_string = ndr->flags;
11322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11323                         if (r->driver_name) {
11324                                 uint32_t _relative_save_offset;
11325                                 _relative_save_offset = ndr->offset;
11326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11327                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11328                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11331                                 if (ndr->offset > ndr->relative_highest_offset) {
11332                                         ndr->relative_highest_offset = ndr->offset;
11333                                 }
11334                                 ndr->offset = _relative_save_offset;
11335                         }
11336                         ndr->flags = _flags_save_string;
11337                 }
11338                 {
11339                         uint32_t _flags_save_string = ndr->flags;
11340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11341                         if (r->architecture) {
11342                                 uint32_t _relative_save_offset;
11343                                 _relative_save_offset = ndr->offset;
11344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11345                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11346                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11349                                 if (ndr->offset > ndr->relative_highest_offset) {
11350                                         ndr->relative_highest_offset = ndr->offset;
11351                                 }
11352                                 ndr->offset = _relative_save_offset;
11353                         }
11354                         ndr->flags = _flags_save_string;
11355                 }
11356                 {
11357                         uint32_t _flags_save_string = ndr->flags;
11358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11359                         if (r->driver_path) {
11360                                 uint32_t _relative_save_offset;
11361                                 _relative_save_offset = ndr->offset;
11362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11363                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11364                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11367                                 if (ndr->offset > ndr->relative_highest_offset) {
11368                                         ndr->relative_highest_offset = ndr->offset;
11369                                 }
11370                                 ndr->offset = _relative_save_offset;
11371                         }
11372                         ndr->flags = _flags_save_string;
11373                 }
11374                 {
11375                         uint32_t _flags_save_string = ndr->flags;
11376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11377                         if (r->data_file) {
11378                                 uint32_t _relative_save_offset;
11379                                 _relative_save_offset = ndr->offset;
11380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11381                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11382                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11383                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11384                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11385                                 if (ndr->offset > ndr->relative_highest_offset) {
11386                                         ndr->relative_highest_offset = ndr->offset;
11387                                 }
11388                                 ndr->offset = _relative_save_offset;
11389                         }
11390                         ndr->flags = _flags_save_string;
11391                 }
11392                 {
11393                         uint32_t _flags_save_string = ndr->flags;
11394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11395                         if (r->config_file) {
11396                                 uint32_t _relative_save_offset;
11397                                 _relative_save_offset = ndr->offset;
11398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11399                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11400                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11403                                 if (ndr->offset > ndr->relative_highest_offset) {
11404                                         ndr->relative_highest_offset = ndr->offset;
11405                                 }
11406                                 ndr->offset = _relative_save_offset;
11407                         }
11408                         ndr->flags = _flags_save_string;
11409                 }
11410                 {
11411                         uint32_t _flags_save_string = ndr->flags;
11412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11413                         if (r->help_file) {
11414                                 uint32_t _relative_save_offset;
11415                                 _relative_save_offset = ndr->offset;
11416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11417                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11418                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11421                                 if (ndr->offset > ndr->relative_highest_offset) {
11422                                         ndr->relative_highest_offset = ndr->offset;
11423                                 }
11424                                 ndr->offset = _relative_save_offset;
11425                         }
11426                         ndr->flags = _flags_save_string;
11427                 }
11428                 {
11429                         uint32_t _flags_save_string_array = ndr->flags;
11430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11431                         if (r->dependent_files) {
11432                                 uint32_t _relative_save_offset;
11433                                 _relative_save_offset = ndr->offset;
11434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11435                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11436                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11437                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11439                                 if (ndr->offset > ndr->relative_highest_offset) {
11440                                         ndr->relative_highest_offset = ndr->offset;
11441                                 }
11442                                 ndr->offset = _relative_save_offset;
11443                         }
11444                         ndr->flags = _flags_save_string_array;
11445                 }
11446                 {
11447                         uint32_t _flags_save_string = ndr->flags;
11448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11449                         if (r->monitor_name) {
11450                                 uint32_t _relative_save_offset;
11451                                 _relative_save_offset = ndr->offset;
11452                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11453                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11454                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11455                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11456                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11457                                 if (ndr->offset > ndr->relative_highest_offset) {
11458                                         ndr->relative_highest_offset = ndr->offset;
11459                                 }
11460                                 ndr->offset = _relative_save_offset;
11461                         }
11462                         ndr->flags = _flags_save_string;
11463                 }
11464                 {
11465                         uint32_t _flags_save_string = ndr->flags;
11466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11467                         if (r->default_datatype) {
11468                                 uint32_t _relative_save_offset;
11469                                 _relative_save_offset = ndr->offset;
11470                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11471                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11472                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11473                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11474                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11475                                 if (ndr->offset > ndr->relative_highest_offset) {
11476                                         ndr->relative_highest_offset = ndr->offset;
11477                                 }
11478                                 ndr->offset = _relative_save_offset;
11479                         }
11480                         ndr->flags = _flags_save_string;
11481                 }
11482         }
11483         return NDR_ERR_SUCCESS;
11484 }
11485
11486 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11487 {
11488         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11489         ndr->depth++;
11490         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11491         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11492         ndr->depth++;
11493         if (r->driver_name) {
11494                 ndr_print_string(ndr, "driver_name", r->driver_name);
11495         }
11496         ndr->depth--;
11497         ndr_print_ptr(ndr, "architecture", r->architecture);
11498         ndr->depth++;
11499         if (r->architecture) {
11500                 ndr_print_string(ndr, "architecture", r->architecture);
11501         }
11502         ndr->depth--;
11503         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11504         ndr->depth++;
11505         if (r->driver_path) {
11506                 ndr_print_string(ndr, "driver_path", r->driver_path);
11507         }
11508         ndr->depth--;
11509         ndr_print_ptr(ndr, "data_file", r->data_file);
11510         ndr->depth++;
11511         if (r->data_file) {
11512                 ndr_print_string(ndr, "data_file", r->data_file);
11513         }
11514         ndr->depth--;
11515         ndr_print_ptr(ndr, "config_file", r->config_file);
11516         ndr->depth++;
11517         if (r->config_file) {
11518                 ndr_print_string(ndr, "config_file", r->config_file);
11519         }
11520         ndr->depth--;
11521         ndr_print_ptr(ndr, "help_file", r->help_file);
11522         ndr->depth++;
11523         if (r->help_file) {
11524                 ndr_print_string(ndr, "help_file", r->help_file);
11525         }
11526         ndr->depth--;
11527         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11528         ndr->depth++;
11529         if (r->dependent_files) {
11530                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11531         }
11532         ndr->depth--;
11533         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11534         ndr->depth++;
11535         if (r->monitor_name) {
11536                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11537         }
11538         ndr->depth--;
11539         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11540         ndr->depth++;
11541         if (r->default_datatype) {
11542                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11543         }
11544         ndr->depth--;
11545         ndr->depth--;
11546 }
11547
11548 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11549 {
11550         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11551 }
11552
11553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11554 {
11555         if (ndr_flags & NDR_SCALARS) {
11556                 NDR_CHECK(ndr_push_align(ndr, 5));
11557                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11558                 {
11559                         uint32_t _flags_save_string = ndr->flags;
11560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11562                         ndr->flags = _flags_save_string;
11563                 }
11564                 {
11565                         uint32_t _flags_save_string = ndr->flags;
11566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11568                         ndr->flags = _flags_save_string;
11569                 }
11570                 {
11571                         uint32_t _flags_save_string = ndr->flags;
11572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11574                         ndr->flags = _flags_save_string;
11575                 }
11576                 {
11577                         uint32_t _flags_save_string = ndr->flags;
11578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11580                         ndr->flags = _flags_save_string;
11581                 }
11582                 {
11583                         uint32_t _flags_save_string = ndr->flags;
11584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11586                         ndr->flags = _flags_save_string;
11587                 }
11588                 {
11589                         uint32_t _flags_save_string = ndr->flags;
11590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11592                         ndr->flags = _flags_save_string;
11593                 }
11594                 {
11595                         uint32_t _flags_save_string_array = ndr->flags;
11596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11598                         ndr->flags = _flags_save_string_array;
11599                 }
11600                 {
11601                         uint32_t _flags_save_string = ndr->flags;
11602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11603                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11604                         ndr->flags = _flags_save_string;
11605                 }
11606                 {
11607                         uint32_t _flags_save_string = ndr->flags;
11608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11610                         ndr->flags = _flags_save_string;
11611                 }
11612                 {
11613                         uint32_t _flags_save_string_array = ndr->flags;
11614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11615                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11616                         ndr->flags = _flags_save_string_array;
11617                 }
11618                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11619         }
11620         if (ndr_flags & NDR_BUFFERS) {
11621                 {
11622                         uint32_t _flags_save_string = ndr->flags;
11623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11624                         if (r->driver_name) {
11625                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11626                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11627                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11628                         }
11629                         ndr->flags = _flags_save_string;
11630                 }
11631                 {
11632                         uint32_t _flags_save_string = ndr->flags;
11633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11634                         if (r->architecture) {
11635                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11637                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
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->driver_path) {
11645                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11647                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11648                         }
11649                         ndr->flags = _flags_save_string;
11650                 }
11651                 {
11652                         uint32_t _flags_save_string = ndr->flags;
11653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11654                         if (r->data_file) {
11655                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11657                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11658                         }
11659                         ndr->flags = _flags_save_string;
11660                 }
11661                 {
11662                         uint32_t _flags_save_string = ndr->flags;
11663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11664                         if (r->config_file) {
11665                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11666                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11667                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11668                         }
11669                         ndr->flags = _flags_save_string;
11670                 }
11671                 {
11672                         uint32_t _flags_save_string = ndr->flags;
11673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11674                         if (r->help_file) {
11675                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11676                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11677                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11678                         }
11679                         ndr->flags = _flags_save_string;
11680                 }
11681                 {
11682                         uint32_t _flags_save_string_array = ndr->flags;
11683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11684                         if (r->dependent_files) {
11685                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11686                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11687                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11688                         }
11689                         ndr->flags = _flags_save_string_array;
11690                 }
11691                 {
11692                         uint32_t _flags_save_string = ndr->flags;
11693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11694                         if (r->monitor_name) {
11695                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11696                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11697                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
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                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11706                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11707                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11708                         }
11709                         ndr->flags = _flags_save_string;
11710                 }
11711                 {
11712                         uint32_t _flags_save_string_array = ndr->flags;
11713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11714                         if (r->previous_names) {
11715                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
11716                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11717                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
11718                         }
11719                         ndr->flags = _flags_save_string_array;
11720                 }
11721         }
11722         return NDR_ERR_SUCCESS;
11723 }
11724
11725 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11726 {
11727         uint32_t _ptr_driver_name;
11728         TALLOC_CTX *_mem_save_driver_name_0;
11729         uint32_t _ptr_architecture;
11730         TALLOC_CTX *_mem_save_architecture_0;
11731         uint32_t _ptr_driver_path;
11732         TALLOC_CTX *_mem_save_driver_path_0;
11733         uint32_t _ptr_data_file;
11734         TALLOC_CTX *_mem_save_data_file_0;
11735         uint32_t _ptr_config_file;
11736         TALLOC_CTX *_mem_save_config_file_0;
11737         uint32_t _ptr_help_file;
11738         TALLOC_CTX *_mem_save_help_file_0;
11739         uint32_t _ptr_dependent_files;
11740         TALLOC_CTX *_mem_save_dependent_files_0;
11741         uint32_t _ptr_monitor_name;
11742         TALLOC_CTX *_mem_save_monitor_name_0;
11743         uint32_t _ptr_default_datatype;
11744         TALLOC_CTX *_mem_save_default_datatype_0;
11745         uint32_t _ptr_previous_names;
11746         TALLOC_CTX *_mem_save_previous_names_0;
11747         if (ndr_flags & NDR_SCALARS) {
11748                 NDR_CHECK(ndr_pull_align(ndr, 5));
11749                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11750                 {
11751                         uint32_t _flags_save_string = ndr->flags;
11752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11754                         if (_ptr_driver_name) {
11755                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11757                         } else {
11758                                 r->driver_name = NULL;
11759                         }
11760                         ndr->flags = _flags_save_string;
11761                 }
11762                 {
11763                         uint32_t _flags_save_string = ndr->flags;
11764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11766                         if (_ptr_architecture) {
11767                                 NDR_PULL_ALLOC(ndr, r->architecture);
11768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11769                         } else {
11770                                 r->architecture = NULL;
11771                         }
11772                         ndr->flags = _flags_save_string;
11773                 }
11774                 {
11775                         uint32_t _flags_save_string = ndr->flags;
11776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11777                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11778                         if (_ptr_driver_path) {
11779                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11780                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11781                         } else {
11782                                 r->driver_path = NULL;
11783                         }
11784                         ndr->flags = _flags_save_string;
11785                 }
11786                 {
11787                         uint32_t _flags_save_string = ndr->flags;
11788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11789                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11790                         if (_ptr_data_file) {
11791                                 NDR_PULL_ALLOC(ndr, r->data_file);
11792                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11793                         } else {
11794                                 r->data_file = NULL;
11795                         }
11796                         ndr->flags = _flags_save_string;
11797                 }
11798                 {
11799                         uint32_t _flags_save_string = ndr->flags;
11800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11801                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11802                         if (_ptr_config_file) {
11803                                 NDR_PULL_ALLOC(ndr, r->config_file);
11804                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11805                         } else {
11806                                 r->config_file = NULL;
11807                         }
11808                         ndr->flags = _flags_save_string;
11809                 }
11810                 {
11811                         uint32_t _flags_save_string = ndr->flags;
11812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11813                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11814                         if (_ptr_help_file) {
11815                                 NDR_PULL_ALLOC(ndr, r->help_file);
11816                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11817                         } else {
11818                                 r->help_file = NULL;
11819                         }
11820                         ndr->flags = _flags_save_string;
11821                 }
11822                 {
11823                         uint32_t _flags_save_string_array = ndr->flags;
11824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11825                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11826                         if (_ptr_dependent_files) {
11827                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11828                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11829                         } else {
11830                                 r->dependent_files = NULL;
11831                         }
11832                         ndr->flags = _flags_save_string_array;
11833                 }
11834                 {
11835                         uint32_t _flags_save_string = ndr->flags;
11836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11837                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11838                         if (_ptr_monitor_name) {
11839                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11840                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11841                         } else {
11842                                 r->monitor_name = NULL;
11843                         }
11844                         ndr->flags = _flags_save_string;
11845                 }
11846                 {
11847                         uint32_t _flags_save_string = ndr->flags;
11848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11849                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11850                         if (_ptr_default_datatype) {
11851                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11852                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11853                         } else {
11854                                 r->default_datatype = NULL;
11855                         }
11856                         ndr->flags = _flags_save_string;
11857                 }
11858                 {
11859                         uint32_t _flags_save_string_array = ndr->flags;
11860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11861                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11862                         if (_ptr_previous_names) {
11863                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11864                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11865                         } else {
11866                                 r->previous_names = NULL;
11867                         }
11868                         ndr->flags = _flags_save_string_array;
11869                 }
11870                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11871         }
11872         if (ndr_flags & NDR_BUFFERS) {
11873                 {
11874                         uint32_t _flags_save_string = ndr->flags;
11875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11876                         if (r->driver_name) {
11877                                 uint32_t _relative_save_offset;
11878                                 _relative_save_offset = ndr->offset;
11879                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11880                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11881                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11882                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11883                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11884                                 if (ndr->offset > ndr->relative_highest_offset) {
11885                                         ndr->relative_highest_offset = ndr->offset;
11886                                 }
11887                                 ndr->offset = _relative_save_offset;
11888                         }
11889                         ndr->flags = _flags_save_string;
11890                 }
11891                 {
11892                         uint32_t _flags_save_string = ndr->flags;
11893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11894                         if (r->architecture) {
11895                                 uint32_t _relative_save_offset;
11896                                 _relative_save_offset = ndr->offset;
11897                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11898                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11899                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11900                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11901                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11902                                 if (ndr->offset > ndr->relative_highest_offset) {
11903                                         ndr->relative_highest_offset = ndr->offset;
11904                                 }
11905                                 ndr->offset = _relative_save_offset;
11906                         }
11907                         ndr->flags = _flags_save_string;
11908                 }
11909                 {
11910                         uint32_t _flags_save_string = ndr->flags;
11911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11912                         if (r->driver_path) {
11913                                 uint32_t _relative_save_offset;
11914                                 _relative_save_offset = ndr->offset;
11915                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11916                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11917                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11918                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11919                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11920                                 if (ndr->offset > ndr->relative_highest_offset) {
11921                                         ndr->relative_highest_offset = ndr->offset;
11922                                 }
11923                                 ndr->offset = _relative_save_offset;
11924                         }
11925                         ndr->flags = _flags_save_string;
11926                 }
11927                 {
11928                         uint32_t _flags_save_string = ndr->flags;
11929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11930                         if (r->data_file) {
11931                                 uint32_t _relative_save_offset;
11932                                 _relative_save_offset = ndr->offset;
11933                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11934                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11935                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11936                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11938                                 if (ndr->offset > ndr->relative_highest_offset) {
11939                                         ndr->relative_highest_offset = ndr->offset;
11940                                 }
11941                                 ndr->offset = _relative_save_offset;
11942                         }
11943                         ndr->flags = _flags_save_string;
11944                 }
11945                 {
11946                         uint32_t _flags_save_string = ndr->flags;
11947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11948                         if (r->config_file) {
11949                                 uint32_t _relative_save_offset;
11950                                 _relative_save_offset = ndr->offset;
11951                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11952                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11953                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11954                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11955                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11956                                 if (ndr->offset > ndr->relative_highest_offset) {
11957                                         ndr->relative_highest_offset = ndr->offset;
11958                                 }
11959                                 ndr->offset = _relative_save_offset;
11960                         }
11961                         ndr->flags = _flags_save_string;
11962                 }
11963                 {
11964                         uint32_t _flags_save_string = ndr->flags;
11965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11966                         if (r->help_file) {
11967                                 uint32_t _relative_save_offset;
11968                                 _relative_save_offset = ndr->offset;
11969                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11970                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11971                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11972                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11973                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11974                                 if (ndr->offset > ndr->relative_highest_offset) {
11975                                         ndr->relative_highest_offset = ndr->offset;
11976                                 }
11977                                 ndr->offset = _relative_save_offset;
11978                         }
11979                         ndr->flags = _flags_save_string;
11980                 }
11981                 {
11982                         uint32_t _flags_save_string_array = ndr->flags;
11983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11984                         if (r->dependent_files) {
11985                                 uint32_t _relative_save_offset;
11986                                 _relative_save_offset = ndr->offset;
11987                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11988                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11989                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11990                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11991                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11992                                 if (ndr->offset > ndr->relative_highest_offset) {
11993                                         ndr->relative_highest_offset = ndr->offset;
11994                                 }
11995                                 ndr->offset = _relative_save_offset;
11996                         }
11997                         ndr->flags = _flags_save_string_array;
11998                 }
11999                 {
12000                         uint32_t _flags_save_string = ndr->flags;
12001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12002                         if (r->monitor_name) {
12003                                 uint32_t _relative_save_offset;
12004                                 _relative_save_offset = ndr->offset;
12005                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12006                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12007                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12008                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12009                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12010                                 if (ndr->offset > ndr->relative_highest_offset) {
12011                                         ndr->relative_highest_offset = ndr->offset;
12012                                 }
12013                                 ndr->offset = _relative_save_offset;
12014                         }
12015                         ndr->flags = _flags_save_string;
12016                 }
12017                 {
12018                         uint32_t _flags_save_string = ndr->flags;
12019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12020                         if (r->default_datatype) {
12021                                 uint32_t _relative_save_offset;
12022                                 _relative_save_offset = ndr->offset;
12023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12024                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12025                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12028                                 if (ndr->offset > ndr->relative_highest_offset) {
12029                                         ndr->relative_highest_offset = ndr->offset;
12030                                 }
12031                                 ndr->offset = _relative_save_offset;
12032                         }
12033                         ndr->flags = _flags_save_string;
12034                 }
12035                 {
12036                         uint32_t _flags_save_string_array = ndr->flags;
12037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12038                         if (r->previous_names) {
12039                                 uint32_t _relative_save_offset;
12040                                 _relative_save_offset = ndr->offset;
12041                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12042                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12043                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12044                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12045                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12046                                 if (ndr->offset > ndr->relative_highest_offset) {
12047                                         ndr->relative_highest_offset = ndr->offset;
12048                                 }
12049                                 ndr->offset = _relative_save_offset;
12050                         }
12051                         ndr->flags = _flags_save_string_array;
12052                 }
12053         }
12054         return NDR_ERR_SUCCESS;
12055 }
12056
12057 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
12058 {
12059         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
12060         ndr->depth++;
12061         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12062         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12063         ndr->depth++;
12064         if (r->driver_name) {
12065                 ndr_print_string(ndr, "driver_name", r->driver_name);
12066         }
12067         ndr->depth--;
12068         ndr_print_ptr(ndr, "architecture", r->architecture);
12069         ndr->depth++;
12070         if (r->architecture) {
12071                 ndr_print_string(ndr, "architecture", r->architecture);
12072         }
12073         ndr->depth--;
12074         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12075         ndr->depth++;
12076         if (r->driver_path) {
12077                 ndr_print_string(ndr, "driver_path", r->driver_path);
12078         }
12079         ndr->depth--;
12080         ndr_print_ptr(ndr, "data_file", r->data_file);
12081         ndr->depth++;
12082         if (r->data_file) {
12083                 ndr_print_string(ndr, "data_file", r->data_file);
12084         }
12085         ndr->depth--;
12086         ndr_print_ptr(ndr, "config_file", r->config_file);
12087         ndr->depth++;
12088         if (r->config_file) {
12089                 ndr_print_string(ndr, "config_file", r->config_file);
12090         }
12091         ndr->depth--;
12092         ndr_print_ptr(ndr, "help_file", r->help_file);
12093         ndr->depth++;
12094         if (r->help_file) {
12095                 ndr_print_string(ndr, "help_file", r->help_file);
12096         }
12097         ndr->depth--;
12098         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12099         ndr->depth++;
12100         if (r->dependent_files) {
12101                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12102         }
12103         ndr->depth--;
12104         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12105         ndr->depth++;
12106         if (r->monitor_name) {
12107                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12108         }
12109         ndr->depth--;
12110         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12111         ndr->depth++;
12112         if (r->default_datatype) {
12113                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12114         }
12115         ndr->depth--;
12116         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12117         ndr->depth++;
12118         if (r->previous_names) {
12119                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12120         }
12121         ndr->depth--;
12122         ndr->depth--;
12123 }
12124
12125 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12126 {
12127         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12128 }
12129
12130 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12131 {
12132         if (ndr_flags & NDR_SCALARS) {
12133                 NDR_CHECK(ndr_push_align(ndr, 5));
12134                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12135                 {
12136                         uint32_t _flags_save_string = ndr->flags;
12137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12138                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12139                         ndr->flags = _flags_save_string;
12140                 }
12141                 {
12142                         uint32_t _flags_save_string = ndr->flags;
12143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12144                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12145                         ndr->flags = _flags_save_string;
12146                 }
12147                 {
12148                         uint32_t _flags_save_string = ndr->flags;
12149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12150                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12151                         ndr->flags = _flags_save_string;
12152                 }
12153                 {
12154                         uint32_t _flags_save_string = ndr->flags;
12155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12156                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12157                         ndr->flags = _flags_save_string;
12158                 }
12159                 {
12160                         uint32_t _flags_save_string = ndr->flags;
12161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12162                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12163                         ndr->flags = _flags_save_string;
12164                 }
12165                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12168                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12169         }
12170         if (ndr_flags & NDR_BUFFERS) {
12171                 {
12172                         uint32_t _flags_save_string = ndr->flags;
12173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12174                         if (r->driver_name) {
12175                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12176                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12177                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12178                         }
12179                         ndr->flags = _flags_save_string;
12180                 }
12181                 {
12182                         uint32_t _flags_save_string = ndr->flags;
12183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12184                         if (r->architecture) {
12185                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12186                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12187                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12188                         }
12189                         ndr->flags = _flags_save_string;
12190                 }
12191                 {
12192                         uint32_t _flags_save_string = ndr->flags;
12193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12194                         if (r->driver_path) {
12195                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12196                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12197                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12198                         }
12199                         ndr->flags = _flags_save_string;
12200                 }
12201                 {
12202                         uint32_t _flags_save_string = ndr->flags;
12203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12204                         if (r->data_file) {
12205                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12206                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12207                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12208                         }
12209                         ndr->flags = _flags_save_string;
12210                 }
12211                 {
12212                         uint32_t _flags_save_string = ndr->flags;
12213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12214                         if (r->config_file) {
12215                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12216                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12217                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12218                         }
12219                         ndr->flags = _flags_save_string;
12220                 }
12221         }
12222         return NDR_ERR_SUCCESS;
12223 }
12224
12225 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12226 {
12227         uint32_t _ptr_driver_name;
12228         TALLOC_CTX *_mem_save_driver_name_0;
12229         uint32_t _ptr_architecture;
12230         TALLOC_CTX *_mem_save_architecture_0;
12231         uint32_t _ptr_driver_path;
12232         TALLOC_CTX *_mem_save_driver_path_0;
12233         uint32_t _ptr_data_file;
12234         TALLOC_CTX *_mem_save_data_file_0;
12235         uint32_t _ptr_config_file;
12236         TALLOC_CTX *_mem_save_config_file_0;
12237         if (ndr_flags & NDR_SCALARS) {
12238                 NDR_CHECK(ndr_pull_align(ndr, 5));
12239                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12240                 {
12241                         uint32_t _flags_save_string = ndr->flags;
12242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12243                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12244                         if (_ptr_driver_name) {
12245                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12246                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12247                         } else {
12248                                 r->driver_name = NULL;
12249                         }
12250                         ndr->flags = _flags_save_string;
12251                 }
12252                 {
12253                         uint32_t _flags_save_string = ndr->flags;
12254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12255                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12256                         if (_ptr_architecture) {
12257                                 NDR_PULL_ALLOC(ndr, r->architecture);
12258                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12259                         } else {
12260                                 r->architecture = NULL;
12261                         }
12262                         ndr->flags = _flags_save_string;
12263                 }
12264                 {
12265                         uint32_t _flags_save_string = ndr->flags;
12266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12267                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12268                         if (_ptr_driver_path) {
12269                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12270                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12271                         } else {
12272                                 r->driver_path = NULL;
12273                         }
12274                         ndr->flags = _flags_save_string;
12275                 }
12276                 {
12277                         uint32_t _flags_save_string = ndr->flags;
12278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12279                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12280                         if (_ptr_data_file) {
12281                                 NDR_PULL_ALLOC(ndr, r->data_file);
12282                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12283                         } else {
12284                                 r->data_file = NULL;
12285                         }
12286                         ndr->flags = _flags_save_string;
12287                 }
12288                 {
12289                         uint32_t _flags_save_string = ndr->flags;
12290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12291                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12292                         if (_ptr_config_file) {
12293                                 NDR_PULL_ALLOC(ndr, r->config_file);
12294                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12295                         } else {
12296                                 r->config_file = NULL;
12297                         }
12298                         ndr->flags = _flags_save_string;
12299                 }
12300                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12303                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12304         }
12305         if (ndr_flags & NDR_BUFFERS) {
12306                 {
12307                         uint32_t _flags_save_string = ndr->flags;
12308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12309                         if (r->driver_name) {
12310                                 uint32_t _relative_save_offset;
12311                                 _relative_save_offset = ndr->offset;
12312                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12313                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12314                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12315                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12316                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12317                                 if (ndr->offset > ndr->relative_highest_offset) {
12318                                         ndr->relative_highest_offset = ndr->offset;
12319                                 }
12320                                 ndr->offset = _relative_save_offset;
12321                         }
12322                         ndr->flags = _flags_save_string;
12323                 }
12324                 {
12325                         uint32_t _flags_save_string = ndr->flags;
12326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12327                         if (r->architecture) {
12328                                 uint32_t _relative_save_offset;
12329                                 _relative_save_offset = ndr->offset;
12330                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12331                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12332                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12333                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12334                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12335                                 if (ndr->offset > ndr->relative_highest_offset) {
12336                                         ndr->relative_highest_offset = ndr->offset;
12337                                 }
12338                                 ndr->offset = _relative_save_offset;
12339                         }
12340                         ndr->flags = _flags_save_string;
12341                 }
12342                 {
12343                         uint32_t _flags_save_string = ndr->flags;
12344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12345                         if (r->driver_path) {
12346                                 uint32_t _relative_save_offset;
12347                                 _relative_save_offset = ndr->offset;
12348                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12349                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12350                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12351                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12352                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12353                                 if (ndr->offset > ndr->relative_highest_offset) {
12354                                         ndr->relative_highest_offset = ndr->offset;
12355                                 }
12356                                 ndr->offset = _relative_save_offset;
12357                         }
12358                         ndr->flags = _flags_save_string;
12359                 }
12360                 {
12361                         uint32_t _flags_save_string = ndr->flags;
12362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12363                         if (r->data_file) {
12364                                 uint32_t _relative_save_offset;
12365                                 _relative_save_offset = ndr->offset;
12366                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12367                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12368                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12369                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12370                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12371                                 if (ndr->offset > ndr->relative_highest_offset) {
12372                                         ndr->relative_highest_offset = ndr->offset;
12373                                 }
12374                                 ndr->offset = _relative_save_offset;
12375                         }
12376                         ndr->flags = _flags_save_string;
12377                 }
12378                 {
12379                         uint32_t _flags_save_string = ndr->flags;
12380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12381                         if (r->config_file) {
12382                                 uint32_t _relative_save_offset;
12383                                 _relative_save_offset = ndr->offset;
12384                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12385                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12386                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12387                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12388                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12389                                 if (ndr->offset > ndr->relative_highest_offset) {
12390                                         ndr->relative_highest_offset = ndr->offset;
12391                                 }
12392                                 ndr->offset = _relative_save_offset;
12393                         }
12394                         ndr->flags = _flags_save_string;
12395                 }
12396         }
12397         return NDR_ERR_SUCCESS;
12398 }
12399
12400 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12401 {
12402         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12403         ndr->depth++;
12404         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12405         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12406         ndr->depth++;
12407         if (r->driver_name) {
12408                 ndr_print_string(ndr, "driver_name", r->driver_name);
12409         }
12410         ndr->depth--;
12411         ndr_print_ptr(ndr, "architecture", r->architecture);
12412         ndr->depth++;
12413         if (r->architecture) {
12414                 ndr_print_string(ndr, "architecture", r->architecture);
12415         }
12416         ndr->depth--;
12417         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12418         ndr->depth++;
12419         if (r->driver_path) {
12420                 ndr_print_string(ndr, "driver_path", r->driver_path);
12421         }
12422         ndr->depth--;
12423         ndr_print_ptr(ndr, "data_file", r->data_file);
12424         ndr->depth++;
12425         if (r->data_file) {
12426                 ndr_print_string(ndr, "data_file", r->data_file);
12427         }
12428         ndr->depth--;
12429         ndr_print_ptr(ndr, "config_file", r->config_file);
12430         ndr->depth++;
12431         if (r->config_file) {
12432                 ndr_print_string(ndr, "config_file", r->config_file);
12433         }
12434         ndr->depth--;
12435         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12436         ndr_print_uint32(ndr, "config_version", r->config_version);
12437         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12438         ndr->depth--;
12439 }
12440
12441 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12442 {
12443         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12444 }
12445
12446 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12447 {
12448         if (ndr_flags & NDR_SCALARS) {
12449                 NDR_CHECK(ndr_push_align(ndr, 8));
12450                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12451                 {
12452                         uint32_t _flags_save_string = ndr->flags;
12453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12454                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
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_push_relative_ptr1(ndr, r->architecture));
12461                         ndr->flags = _flags_save_string;
12462                 }
12463                 {
12464                         uint32_t _flags_save_string = ndr->flags;
12465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12466                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12467                         ndr->flags = _flags_save_string;
12468                 }
12469                 {
12470                         uint32_t _flags_save_string = ndr->flags;
12471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12472                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12473                         ndr->flags = _flags_save_string;
12474                 }
12475                 {
12476                         uint32_t _flags_save_string = ndr->flags;
12477                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12478                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12479                         ndr->flags = _flags_save_string;
12480                 }
12481                 {
12482                         uint32_t _flags_save_string = ndr->flags;
12483                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12484                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12485                         ndr->flags = _flags_save_string;
12486                 }
12487                 {
12488                         uint32_t _flags_save_string_array = ndr->flags;
12489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12490                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12491                         ndr->flags = _flags_save_string_array;
12492                 }
12493                 {
12494                         uint32_t _flags_save_string = ndr->flags;
12495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12496                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12497                         ndr->flags = _flags_save_string;
12498                 }
12499                 {
12500                         uint32_t _flags_save_string = ndr->flags;
12501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12502                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12503                         ndr->flags = _flags_save_string;
12504                 }
12505                 {
12506                         uint32_t _flags_save_string_array = ndr->flags;
12507                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12508                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12509                         ndr->flags = _flags_save_string_array;
12510                 }
12511                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12512                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12513                 {
12514                         uint32_t _flags_save_string = ndr->flags;
12515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12516                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
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_push_relative_ptr1(ndr, r->manufacturer_url));
12523                         ndr->flags = _flags_save_string;
12524                 }
12525                 {
12526                         uint32_t _flags_save_string = ndr->flags;
12527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12528                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12529                         ndr->flags = _flags_save_string;
12530                 }
12531                 {
12532                         uint32_t _flags_save_string = ndr->flags;
12533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12534                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12535                         ndr->flags = _flags_save_string;
12536                 }
12537                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12538         }
12539         if (ndr_flags & NDR_BUFFERS) {
12540                 {
12541                         uint32_t _flags_save_string = ndr->flags;
12542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12543                         if (r->driver_name) {
12544                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12545                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12546                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12547                         }
12548                         ndr->flags = _flags_save_string;
12549                 }
12550                 {
12551                         uint32_t _flags_save_string = ndr->flags;
12552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12553                         if (r->architecture) {
12554                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12555                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12556                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12557                         }
12558                         ndr->flags = _flags_save_string;
12559                 }
12560                 {
12561                         uint32_t _flags_save_string = ndr->flags;
12562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12563                         if (r->driver_path) {
12564                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12565                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12566                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12567                         }
12568                         ndr->flags = _flags_save_string;
12569                 }
12570                 {
12571                         uint32_t _flags_save_string = ndr->flags;
12572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12573                         if (r->data_file) {
12574                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12575                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12576                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12577                         }
12578                         ndr->flags = _flags_save_string;
12579                 }
12580                 {
12581                         uint32_t _flags_save_string = ndr->flags;
12582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12583                         if (r->config_file) {
12584                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12585                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12586                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12587                         }
12588                         ndr->flags = _flags_save_string;
12589                 }
12590                 {
12591                         uint32_t _flags_save_string = ndr->flags;
12592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12593                         if (r->help_file) {
12594                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12596                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12597                         }
12598                         ndr->flags = _flags_save_string;
12599                 }
12600                 {
12601                         uint32_t _flags_save_string_array = ndr->flags;
12602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12603                         if (r->dependent_files) {
12604                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12605                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12606                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12607                         }
12608                         ndr->flags = _flags_save_string_array;
12609                 }
12610                 {
12611                         uint32_t _flags_save_string = ndr->flags;
12612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12613                         if (r->monitor_name) {
12614                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12616                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12617                         }
12618                         ndr->flags = _flags_save_string;
12619                 }
12620                 {
12621                         uint32_t _flags_save_string = ndr->flags;
12622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12623                         if (r->default_datatype) {
12624                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12625                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12626                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12627                         }
12628                         ndr->flags = _flags_save_string;
12629                 }
12630                 {
12631                         uint32_t _flags_save_string_array = ndr->flags;
12632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12633                         if (r->previous_names) {
12634                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12635                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12636                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12637                         }
12638                         ndr->flags = _flags_save_string_array;
12639                 }
12640                 {
12641                         uint32_t _flags_save_string = ndr->flags;
12642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12643                         if (r->manufacturer_name) {
12644                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12645                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12646                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12647                         }
12648                         ndr->flags = _flags_save_string;
12649                 }
12650                 {
12651                         uint32_t _flags_save_string = ndr->flags;
12652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12653                         if (r->manufacturer_url) {
12654                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12656                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12657                         }
12658                         ndr->flags = _flags_save_string;
12659                 }
12660                 {
12661                         uint32_t _flags_save_string = ndr->flags;
12662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12663                         if (r->hardware_id) {
12664                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12666                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
12667                         }
12668                         ndr->flags = _flags_save_string;
12669                 }
12670                 {
12671                         uint32_t _flags_save_string = ndr->flags;
12672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12673                         if (r->provider) {
12674                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12675                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12676                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12677                         }
12678                         ndr->flags = _flags_save_string;
12679                 }
12680         }
12681         return NDR_ERR_SUCCESS;
12682 }
12683
12684 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12685 {
12686         uint32_t _ptr_driver_name;
12687         TALLOC_CTX *_mem_save_driver_name_0;
12688         uint32_t _ptr_architecture;
12689         TALLOC_CTX *_mem_save_architecture_0;
12690         uint32_t _ptr_driver_path;
12691         TALLOC_CTX *_mem_save_driver_path_0;
12692         uint32_t _ptr_data_file;
12693         TALLOC_CTX *_mem_save_data_file_0;
12694         uint32_t _ptr_config_file;
12695         TALLOC_CTX *_mem_save_config_file_0;
12696         uint32_t _ptr_help_file;
12697         TALLOC_CTX *_mem_save_help_file_0;
12698         uint32_t _ptr_dependent_files;
12699         TALLOC_CTX *_mem_save_dependent_files_0;
12700         uint32_t _ptr_monitor_name;
12701         TALLOC_CTX *_mem_save_monitor_name_0;
12702         uint32_t _ptr_default_datatype;
12703         TALLOC_CTX *_mem_save_default_datatype_0;
12704         uint32_t _ptr_previous_names;
12705         TALLOC_CTX *_mem_save_previous_names_0;
12706         uint32_t _ptr_manufacturer_name;
12707         TALLOC_CTX *_mem_save_manufacturer_name_0;
12708         uint32_t _ptr_manufacturer_url;
12709         TALLOC_CTX *_mem_save_manufacturer_url_0;
12710         uint32_t _ptr_hardware_id;
12711         TALLOC_CTX *_mem_save_hardware_id_0;
12712         uint32_t _ptr_provider;
12713         TALLOC_CTX *_mem_save_provider_0;
12714         if (ndr_flags & NDR_SCALARS) {
12715                 NDR_CHECK(ndr_pull_align(ndr, 8));
12716                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12717                 {
12718                         uint32_t _flags_save_string = ndr->flags;
12719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12721                         if (_ptr_driver_name) {
12722                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12724                         } else {
12725                                 r->driver_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12733                         if (_ptr_architecture) {
12734                                 NDR_PULL_ALLOC(ndr, r->architecture);
12735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12736                         } else {
12737                                 r->architecture = NULL;
12738                         }
12739                         ndr->flags = _flags_save_string;
12740                 }
12741                 {
12742                         uint32_t _flags_save_string = ndr->flags;
12743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12745                         if (_ptr_driver_path) {
12746                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12748                         } else {
12749                                 r->driver_path = NULL;
12750                         }
12751                         ndr->flags = _flags_save_string;
12752                 }
12753                 {
12754                         uint32_t _flags_save_string = ndr->flags;
12755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12757                         if (_ptr_data_file) {
12758                                 NDR_PULL_ALLOC(ndr, r->data_file);
12759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12760                         } else {
12761                                 r->data_file = NULL;
12762                         }
12763                         ndr->flags = _flags_save_string;
12764                 }
12765                 {
12766                         uint32_t _flags_save_string = ndr->flags;
12767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12768                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12769                         if (_ptr_config_file) {
12770                                 NDR_PULL_ALLOC(ndr, r->config_file);
12771                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12772                         } else {
12773                                 r->config_file = NULL;
12774                         }
12775                         ndr->flags = _flags_save_string;
12776                 }
12777                 {
12778                         uint32_t _flags_save_string = ndr->flags;
12779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12780                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12781                         if (_ptr_help_file) {
12782                                 NDR_PULL_ALLOC(ndr, r->help_file);
12783                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12784                         } else {
12785                                 r->help_file = NULL;
12786                         }
12787                         ndr->flags = _flags_save_string;
12788                 }
12789                 {
12790                         uint32_t _flags_save_string_array = ndr->flags;
12791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12792                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12793                         if (_ptr_dependent_files) {
12794                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12795                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12796                         } else {
12797                                 r->dependent_files = NULL;
12798                         }
12799                         ndr->flags = _flags_save_string_array;
12800                 }
12801                 {
12802                         uint32_t _flags_save_string = ndr->flags;
12803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12804                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12805                         if (_ptr_monitor_name) {
12806                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12807                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12808                         } else {
12809                                 r->monitor_name = NULL;
12810                         }
12811                         ndr->flags = _flags_save_string;
12812                 }
12813                 {
12814                         uint32_t _flags_save_string = ndr->flags;
12815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12816                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12817                         if (_ptr_default_datatype) {
12818                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12819                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12820                         } else {
12821                                 r->default_datatype = NULL;
12822                         }
12823                         ndr->flags = _flags_save_string;
12824                 }
12825                 {
12826                         uint32_t _flags_save_string_array = ndr->flags;
12827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12828                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12829                         if (_ptr_previous_names) {
12830                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12831                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12832                         } else {
12833                                 r->previous_names = NULL;
12834                         }
12835                         ndr->flags = _flags_save_string_array;
12836                 }
12837                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12838                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12839                 {
12840                         uint32_t _flags_save_string = ndr->flags;
12841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12842                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12843                         if (_ptr_manufacturer_name) {
12844                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12845                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12846                         } else {
12847                                 r->manufacturer_name = NULL;
12848                         }
12849                         ndr->flags = _flags_save_string;
12850                 }
12851                 {
12852                         uint32_t _flags_save_string = ndr->flags;
12853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12854                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12855                         if (_ptr_manufacturer_url) {
12856                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12857                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12858                         } else {
12859                                 r->manufacturer_url = NULL;
12860                         }
12861                         ndr->flags = _flags_save_string;
12862                 }
12863                 {
12864                         uint32_t _flags_save_string = ndr->flags;
12865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12866                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12867                         if (_ptr_hardware_id) {
12868                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12869                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12870                         } else {
12871                                 r->hardware_id = NULL;
12872                         }
12873                         ndr->flags = _flags_save_string;
12874                 }
12875                 {
12876                         uint32_t _flags_save_string = ndr->flags;
12877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12878                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12879                         if (_ptr_provider) {
12880                                 NDR_PULL_ALLOC(ndr, r->provider);
12881                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12882                         } else {
12883                                 r->provider = NULL;
12884                         }
12885                         ndr->flags = _flags_save_string;
12886                 }
12887                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12888         }
12889         if (ndr_flags & NDR_BUFFERS) {
12890                 {
12891                         uint32_t _flags_save_string = ndr->flags;
12892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12893                         if (r->driver_name) {
12894                                 uint32_t _relative_save_offset;
12895                                 _relative_save_offset = ndr->offset;
12896                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12897                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12898                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12899                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12900                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12901                                 if (ndr->offset > ndr->relative_highest_offset) {
12902                                         ndr->relative_highest_offset = ndr->offset;
12903                                 }
12904                                 ndr->offset = _relative_save_offset;
12905                         }
12906                         ndr->flags = _flags_save_string;
12907                 }
12908                 {
12909                         uint32_t _flags_save_string = ndr->flags;
12910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12911                         if (r->architecture) {
12912                                 uint32_t _relative_save_offset;
12913                                 _relative_save_offset = ndr->offset;
12914                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12915                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12916                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12917                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12918                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12919                                 if (ndr->offset > ndr->relative_highest_offset) {
12920                                         ndr->relative_highest_offset = ndr->offset;
12921                                 }
12922                                 ndr->offset = _relative_save_offset;
12923                         }
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                         if (r->driver_path) {
12930                                 uint32_t _relative_save_offset;
12931                                 _relative_save_offset = ndr->offset;
12932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12933                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12934                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12937                                 if (ndr->offset > ndr->relative_highest_offset) {
12938                                         ndr->relative_highest_offset = ndr->offset;
12939                                 }
12940                                 ndr->offset = _relative_save_offset;
12941                         }
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                         if (r->data_file) {
12948                                 uint32_t _relative_save_offset;
12949                                 _relative_save_offset = ndr->offset;
12950                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12951                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12952                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12953                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12954                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12955                                 if (ndr->offset > ndr->relative_highest_offset) {
12956                                         ndr->relative_highest_offset = ndr->offset;
12957                                 }
12958                                 ndr->offset = _relative_save_offset;
12959                         }
12960                         ndr->flags = _flags_save_string;
12961                 }
12962                 {
12963                         uint32_t _flags_save_string = ndr->flags;
12964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12965                         if (r->config_file) {
12966                                 uint32_t _relative_save_offset;
12967                                 _relative_save_offset = ndr->offset;
12968                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12969                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12970                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12971                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12972                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12973                                 if (ndr->offset > ndr->relative_highest_offset) {
12974                                         ndr->relative_highest_offset = ndr->offset;
12975                                 }
12976                                 ndr->offset = _relative_save_offset;
12977                         }
12978                         ndr->flags = _flags_save_string;
12979                 }
12980                 {
12981                         uint32_t _flags_save_string = ndr->flags;
12982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12983                         if (r->help_file) {
12984                                 uint32_t _relative_save_offset;
12985                                 _relative_save_offset = ndr->offset;
12986                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12987                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12988                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12989                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12990                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12991                                 if (ndr->offset > ndr->relative_highest_offset) {
12992                                         ndr->relative_highest_offset = ndr->offset;
12993                                 }
12994                                 ndr->offset = _relative_save_offset;
12995                         }
12996                         ndr->flags = _flags_save_string;
12997                 }
12998                 {
12999                         uint32_t _flags_save_string_array = ndr->flags;
13000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13001                         if (r->dependent_files) {
13002                                 uint32_t _relative_save_offset;
13003                                 _relative_save_offset = ndr->offset;
13004                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13005                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13006                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13007                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13008                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13009                                 if (ndr->offset > ndr->relative_highest_offset) {
13010                                         ndr->relative_highest_offset = ndr->offset;
13011                                 }
13012                                 ndr->offset = _relative_save_offset;
13013                         }
13014                         ndr->flags = _flags_save_string_array;
13015                 }
13016                 {
13017                         uint32_t _flags_save_string = ndr->flags;
13018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13019                         if (r->monitor_name) {
13020                                 uint32_t _relative_save_offset;
13021                                 _relative_save_offset = ndr->offset;
13022                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13023                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13024                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13025                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13026                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13027                                 if (ndr->offset > ndr->relative_highest_offset) {
13028                                         ndr->relative_highest_offset = ndr->offset;
13029                                 }
13030                                 ndr->offset = _relative_save_offset;
13031                         }
13032                         ndr->flags = _flags_save_string;
13033                 }
13034                 {
13035                         uint32_t _flags_save_string = ndr->flags;
13036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13037                         if (r->default_datatype) {
13038                                 uint32_t _relative_save_offset;
13039                                 _relative_save_offset = ndr->offset;
13040                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13041                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13042                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13043                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13044                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13045                                 if (ndr->offset > ndr->relative_highest_offset) {
13046                                         ndr->relative_highest_offset = ndr->offset;
13047                                 }
13048                                 ndr->offset = _relative_save_offset;
13049                         }
13050                         ndr->flags = _flags_save_string;
13051                 }
13052                 {
13053                         uint32_t _flags_save_string_array = ndr->flags;
13054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13055                         if (r->previous_names) {
13056                                 uint32_t _relative_save_offset;
13057                                 _relative_save_offset = ndr->offset;
13058                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13059                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13060                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13061                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13062                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13063                                 if (ndr->offset > ndr->relative_highest_offset) {
13064                                         ndr->relative_highest_offset = ndr->offset;
13065                                 }
13066                                 ndr->offset = _relative_save_offset;
13067                         }
13068                         ndr->flags = _flags_save_string_array;
13069                 }
13070                 {
13071                         uint32_t _flags_save_string = ndr->flags;
13072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13073                         if (r->manufacturer_name) {
13074                                 uint32_t _relative_save_offset;
13075                                 _relative_save_offset = ndr->offset;
13076                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13077                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13078                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13079                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13080                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13081                                 if (ndr->offset > ndr->relative_highest_offset) {
13082                                         ndr->relative_highest_offset = ndr->offset;
13083                                 }
13084                                 ndr->offset = _relative_save_offset;
13085                         }
13086                         ndr->flags = _flags_save_string;
13087                 }
13088                 {
13089                         uint32_t _flags_save_string = ndr->flags;
13090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13091                         if (r->manufacturer_url) {
13092                                 uint32_t _relative_save_offset;
13093                                 _relative_save_offset = ndr->offset;
13094                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13095                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13096                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13097                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13098                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13099                                 if (ndr->offset > ndr->relative_highest_offset) {
13100                                         ndr->relative_highest_offset = ndr->offset;
13101                                 }
13102                                 ndr->offset = _relative_save_offset;
13103                         }
13104                         ndr->flags = _flags_save_string;
13105                 }
13106                 {
13107                         uint32_t _flags_save_string = ndr->flags;
13108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13109                         if (r->hardware_id) {
13110                                 uint32_t _relative_save_offset;
13111                                 _relative_save_offset = ndr->offset;
13112                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13113                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13114                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13115                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13116                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13117                                 if (ndr->offset > ndr->relative_highest_offset) {
13118                                         ndr->relative_highest_offset = ndr->offset;
13119                                 }
13120                                 ndr->offset = _relative_save_offset;
13121                         }
13122                         ndr->flags = _flags_save_string;
13123                 }
13124                 {
13125                         uint32_t _flags_save_string = ndr->flags;
13126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13127                         if (r->provider) {
13128                                 uint32_t _relative_save_offset;
13129                                 _relative_save_offset = ndr->offset;
13130                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13131                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13132                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13133                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13134                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13135                                 if (ndr->offset > ndr->relative_highest_offset) {
13136                                         ndr->relative_highest_offset = ndr->offset;
13137                                 }
13138                                 ndr->offset = _relative_save_offset;
13139                         }
13140                         ndr->flags = _flags_save_string;
13141                 }
13142         }
13143         return NDR_ERR_SUCCESS;
13144 }
13145
13146 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13147 {
13148         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13149         ndr->depth++;
13150         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13151         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13152         ndr->depth++;
13153         if (r->driver_name) {
13154                 ndr_print_string(ndr, "driver_name", r->driver_name);
13155         }
13156         ndr->depth--;
13157         ndr_print_ptr(ndr, "architecture", r->architecture);
13158         ndr->depth++;
13159         if (r->architecture) {
13160                 ndr_print_string(ndr, "architecture", r->architecture);
13161         }
13162         ndr->depth--;
13163         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13164         ndr->depth++;
13165         if (r->driver_path) {
13166                 ndr_print_string(ndr, "driver_path", r->driver_path);
13167         }
13168         ndr->depth--;
13169         ndr_print_ptr(ndr, "data_file", r->data_file);
13170         ndr->depth++;
13171         if (r->data_file) {
13172                 ndr_print_string(ndr, "data_file", r->data_file);
13173         }
13174         ndr->depth--;
13175         ndr_print_ptr(ndr, "config_file", r->config_file);
13176         ndr->depth++;
13177         if (r->config_file) {
13178                 ndr_print_string(ndr, "config_file", r->config_file);
13179         }
13180         ndr->depth--;
13181         ndr_print_ptr(ndr, "help_file", r->help_file);
13182         ndr->depth++;
13183         if (r->help_file) {
13184                 ndr_print_string(ndr, "help_file", r->help_file);
13185         }
13186         ndr->depth--;
13187         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13188         ndr->depth++;
13189         if (r->dependent_files) {
13190                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13191         }
13192         ndr->depth--;
13193         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13194         ndr->depth++;
13195         if (r->monitor_name) {
13196                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13197         }
13198         ndr->depth--;
13199         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13200         ndr->depth++;
13201         if (r->default_datatype) {
13202                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13203         }
13204         ndr->depth--;
13205         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13206         ndr->depth++;
13207         if (r->previous_names) {
13208                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13209         }
13210         ndr->depth--;
13211         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13212         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13213         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13214         ndr->depth++;
13215         if (r->manufacturer_name) {
13216                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13217         }
13218         ndr->depth--;
13219         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13220         ndr->depth++;
13221         if (r->manufacturer_url) {
13222                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13223         }
13224         ndr->depth--;
13225         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13226         ndr->depth++;
13227         if (r->hardware_id) {
13228                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13229         }
13230         ndr->depth--;
13231         ndr_print_ptr(ndr, "provider", r->provider);
13232         ndr->depth++;
13233         if (r->provider) {
13234                 ndr_print_string(ndr, "provider", r->provider);
13235         }
13236         ndr->depth--;
13237         ndr->depth--;
13238 }
13239
13240 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13241 {
13242         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13243 }
13244
13245 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
13246 {
13247         if (ndr_flags & NDR_SCALARS) {
13248                 NDR_CHECK(ndr_push_align(ndr, 5));
13249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13250                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13251                 {
13252                         uint32_t _flags_save_string = ndr->flags;
13253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13255                         ndr->flags = _flags_save_string;
13256                 }
13257                 {
13258                         uint32_t _flags_save_string = ndr->flags;
13259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13260                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
13261                         ndr->flags = _flags_save_string;
13262                 }
13263                 {
13264                         uint32_t _flags_save_string = ndr->flags;
13265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13266                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
13267                         ndr->flags = _flags_save_string;
13268                 }
13269                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13270         }
13271         if (ndr_flags & NDR_BUFFERS) {
13272                 {
13273                         uint32_t _flags_save_string = ndr->flags;
13274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13275                         if (r->driver_name) {
13276                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13278                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13279                         }
13280                         ndr->flags = _flags_save_string;
13281                 }
13282                 {
13283                         uint32_t _flags_save_string = ndr->flags;
13284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13285                         if (r->inf_name) {
13286                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_name));
13287                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
13288                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_name));
13289                         }
13290                         ndr->flags = _flags_save_string;
13291                 }
13292                 {
13293                         uint32_t _flags_save_string = ndr->flags;
13294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13295                         if (r->install_source_root) {
13296                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->install_source_root));
13297                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
13298                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->install_source_root));
13299                         }
13300                         ndr->flags = _flags_save_string;
13301                 }
13302         }
13303         return NDR_ERR_SUCCESS;
13304 }
13305
13306 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
13307 {
13308         uint32_t _ptr_driver_name;
13309         TALLOC_CTX *_mem_save_driver_name_0;
13310         uint32_t _ptr_inf_name;
13311         TALLOC_CTX *_mem_save_inf_name_0;
13312         uint32_t _ptr_install_source_root;
13313         TALLOC_CTX *_mem_save_install_source_root_0;
13314         if (ndr_flags & NDR_SCALARS) {
13315                 NDR_CHECK(ndr_pull_align(ndr, 5));
13316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13317                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13318                 {
13319                         uint32_t _flags_save_string = ndr->flags;
13320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13321                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13322                         if (_ptr_driver_name) {
13323                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13324                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13325                         } else {
13326                                 r->driver_name = NULL;
13327                         }
13328                         ndr->flags = _flags_save_string;
13329                 }
13330                 {
13331                         uint32_t _flags_save_string = ndr->flags;
13332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13333                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13334                         if (_ptr_inf_name) {
13335                                 NDR_PULL_ALLOC(ndr, r->inf_name);
13336                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13337                         } else {
13338                                 r->inf_name = NULL;
13339                         }
13340                         ndr->flags = _flags_save_string;
13341                 }
13342                 {
13343                         uint32_t _flags_save_string = ndr->flags;
13344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13345                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13346                         if (_ptr_install_source_root) {
13347                                 NDR_PULL_ALLOC(ndr, r->install_source_root);
13348                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13349                         } else {
13350                                 r->install_source_root = NULL;
13351                         }
13352                         ndr->flags = _flags_save_string;
13353                 }
13354                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13355         }
13356         if (ndr_flags & NDR_BUFFERS) {
13357                 {
13358                         uint32_t _flags_save_string = ndr->flags;
13359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13360                         if (r->driver_name) {
13361                                 uint32_t _relative_save_offset;
13362                                 _relative_save_offset = ndr->offset;
13363                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13364                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13365                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13366                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13367                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13368                                 if (ndr->offset > ndr->relative_highest_offset) {
13369                                         ndr->relative_highest_offset = ndr->offset;
13370                                 }
13371                                 ndr->offset = _relative_save_offset;
13372                         }
13373                         ndr->flags = _flags_save_string;
13374                 }
13375                 {
13376                         uint32_t _flags_save_string = ndr->flags;
13377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13378                         if (r->inf_name) {
13379                                 uint32_t _relative_save_offset;
13380                                 _relative_save_offset = ndr->offset;
13381                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13382                                 _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13383                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13384                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13385                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13386                                 if (ndr->offset > ndr->relative_highest_offset) {
13387                                         ndr->relative_highest_offset = ndr->offset;
13388                                 }
13389                                 ndr->offset = _relative_save_offset;
13390                         }
13391                         ndr->flags = _flags_save_string;
13392                 }
13393                 {
13394                         uint32_t _flags_save_string = ndr->flags;
13395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13396                         if (r->install_source_root) {
13397                                 uint32_t _relative_save_offset;
13398                                 _relative_save_offset = ndr->offset;
13399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13400                                 _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13401                                 NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13404                                 if (ndr->offset > ndr->relative_highest_offset) {
13405                                         ndr->relative_highest_offset = ndr->offset;
13406                                 }
13407                                 ndr->offset = _relative_save_offset;
13408                         }
13409                         ndr->flags = _flags_save_string;
13410                 }
13411         }
13412         return NDR_ERR_SUCCESS;
13413 }
13414
13415 _PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13416 {
13417         ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13418         ndr->depth++;
13419         ndr_print_uint32(ndr, "size", r->size);
13420         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13421         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13422         ndr->depth++;
13423         if (r->driver_name) {
13424                 ndr_print_string(ndr, "driver_name", r->driver_name);
13425         }
13426         ndr->depth--;
13427         ndr_print_ptr(ndr, "inf_name", r->inf_name);
13428         ndr->depth++;
13429         if (r->inf_name) {
13430                 ndr_print_string(ndr, "inf_name", r->inf_name);
13431         }
13432         ndr->depth--;
13433         ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13434         ndr->depth++;
13435         if (r->install_source_root) {
13436                 ndr_print_string(ndr, "install_source_root", r->install_source_root);
13437         }
13438         ndr->depth--;
13439         ndr->depth--;
13440 }
13441
13442 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13443 {
13444         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13445 }
13446
13447 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13448 {
13449         if (ndr_flags & NDR_SCALARS) {
13450                 NDR_CHECK(ndr_push_align(ndr, 8));
13451                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13452                 {
13453                         uint32_t _flags_save_string = ndr->flags;
13454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13455                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13462                         ndr->flags = _flags_save_string;
13463                 }
13464                 {
13465                         uint32_t _flags_save_string = ndr->flags;
13466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13467                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13468                         ndr->flags = _flags_save_string;
13469                 }
13470                 {
13471                         uint32_t _flags_save_string = ndr->flags;
13472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13473                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13474                         ndr->flags = _flags_save_string;
13475                 }
13476                 {
13477                         uint32_t _flags_save_string = ndr->flags;
13478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13479                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13480                         ndr->flags = _flags_save_string;
13481                 }
13482                 {
13483                         uint32_t _flags_save_string = ndr->flags;
13484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13485                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13486                         ndr->flags = _flags_save_string;
13487                 }
13488                 {
13489                         uint32_t _flags_save_string_array = ndr->flags;
13490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13491                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13492                         ndr->flags = _flags_save_string_array;
13493                 }
13494                 {
13495                         uint32_t _flags_save_string = ndr->flags;
13496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13497                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13498                         ndr->flags = _flags_save_string;
13499                 }
13500                 {
13501                         uint32_t _flags_save_string = ndr->flags;
13502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13503                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13504                         ndr->flags = _flags_save_string;
13505                 }
13506                 {
13507                         uint32_t _flags_save_string_array = ndr->flags;
13508                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13509                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13510                         ndr->flags = _flags_save_string_array;
13511                 }
13512                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13513                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13514                 {
13515                         uint32_t _flags_save_string = ndr->flags;
13516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13518                         ndr->flags = _flags_save_string;
13519                 }
13520                 {
13521                         uint32_t _flags_save_string = ndr->flags;
13522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13524                         ndr->flags = _flags_save_string;
13525                 }
13526                 {
13527                         uint32_t _flags_save_string = ndr->flags;
13528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13530                         ndr->flags = _flags_save_string;
13531                 }
13532                 {
13533                         uint32_t _flags_save_string = ndr->flags;
13534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13536                         ndr->flags = _flags_save_string;
13537                 }
13538                 {
13539                         uint32_t _flags_save_string = ndr->flags;
13540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13541                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13542                         ndr->flags = _flags_save_string;
13543                 }
13544                 {
13545                         uint32_t _flags_save_string = ndr->flags;
13546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13548                         ndr->flags = _flags_save_string;
13549                 }
13550                 {
13551                         uint32_t _flags_save_string_array = ndr->flags;
13552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13553                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13554                         ndr->flags = _flags_save_string_array;
13555                 }
13556                 {
13557                         uint32_t _flags_save_string = ndr->flags;
13558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13559                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13560                         ndr->flags = _flags_save_string;
13561                 }
13562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13563                 {
13564                         uint32_t _flags_save_string_array = ndr->flags;
13565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13566                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13567                         ndr->flags = _flags_save_string_array;
13568                 }
13569                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13570                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13571                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13572         }
13573         if (ndr_flags & NDR_BUFFERS) {
13574                 {
13575                         uint32_t _flags_save_string = ndr->flags;
13576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13577                         if (r->driver_name) {
13578                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13580                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13581                         }
13582                         ndr->flags = _flags_save_string;
13583                 }
13584                 {
13585                         uint32_t _flags_save_string = ndr->flags;
13586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13587                         if (r->architecture) {
13588                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
13589                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13590                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
13591                         }
13592                         ndr->flags = _flags_save_string;
13593                 }
13594                 {
13595                         uint32_t _flags_save_string = ndr->flags;
13596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13597                         if (r->driver_path) {
13598                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
13599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13600                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
13601                         }
13602                         ndr->flags = _flags_save_string;
13603                 }
13604                 {
13605                         uint32_t _flags_save_string = ndr->flags;
13606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13607                         if (r->data_file) {
13608                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
13609                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13610                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
13611                         }
13612                         ndr->flags = _flags_save_string;
13613                 }
13614                 {
13615                         uint32_t _flags_save_string = ndr->flags;
13616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13617                         if (r->config_file) {
13618                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
13619                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13620                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
13621                         }
13622                         ndr->flags = _flags_save_string;
13623                 }
13624                 {
13625                         uint32_t _flags_save_string = ndr->flags;
13626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13627                         if (r->help_file) {
13628                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
13629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13630                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
13631                         }
13632                         ndr->flags = _flags_save_string;
13633                 }
13634                 {
13635                         uint32_t _flags_save_string_array = ndr->flags;
13636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13637                         if (r->dependent_files) {
13638                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
13639                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13640                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
13641                         }
13642                         ndr->flags = _flags_save_string_array;
13643                 }
13644                 {
13645                         uint32_t _flags_save_string = ndr->flags;
13646                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13647                         if (r->monitor_name) {
13648                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
13649                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13650                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
13651                         }
13652                         ndr->flags = _flags_save_string;
13653                 }
13654                 {
13655                         uint32_t _flags_save_string = ndr->flags;
13656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13657                         if (r->default_datatype) {
13658                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
13659                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13660                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
13661                         }
13662                         ndr->flags = _flags_save_string;
13663                 }
13664                 {
13665                         uint32_t _flags_save_string_array = ndr->flags;
13666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13667                         if (r->previous_names) {
13668                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
13669                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13670                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
13671                         }
13672                         ndr->flags = _flags_save_string_array;
13673                 }
13674                 {
13675                         uint32_t _flags_save_string = ndr->flags;
13676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13677                         if (r->manufacturer_name) {
13678                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
13679                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13680                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
13681                         }
13682                         ndr->flags = _flags_save_string;
13683                 }
13684                 {
13685                         uint32_t _flags_save_string = ndr->flags;
13686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13687                         if (r->manufacturer_url) {
13688                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
13689                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13690                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
13691                         }
13692                         ndr->flags = _flags_save_string;
13693                 }
13694                 {
13695                         uint32_t _flags_save_string = ndr->flags;
13696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13697                         if (r->hardware_id) {
13698                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
13699                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13700                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
13701                         }
13702                         ndr->flags = _flags_save_string;
13703                 }
13704                 {
13705                         uint32_t _flags_save_string = ndr->flags;
13706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13707                         if (r->provider) {
13708                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
13709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13710                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
13711                         }
13712                         ndr->flags = _flags_save_string;
13713                 }
13714                 {
13715                         uint32_t _flags_save_string = ndr->flags;
13716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13717                         if (r->print_processor) {
13718                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
13719                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13720                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
13721                         }
13722                         ndr->flags = _flags_save_string;
13723                 }
13724                 {
13725                         uint32_t _flags_save_string = ndr->flags;
13726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13727                         if (r->vendor_setup) {
13728                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->vendor_setup));
13729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13730                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->vendor_setup));
13731                         }
13732                         ndr->flags = _flags_save_string;
13733                 }
13734                 {
13735                         uint32_t _flags_save_string_array = ndr->flags;
13736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13737                         if (r->color_profiles) {
13738                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->color_profiles));
13739                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13740                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->color_profiles));
13741                         }
13742                         ndr->flags = _flags_save_string_array;
13743                 }
13744                 {
13745                         uint32_t _flags_save_string = ndr->flags;
13746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13747                         if (r->inf_path) {
13748                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_path));
13749                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13750                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_path));
13751                         }
13752                         ndr->flags = _flags_save_string;
13753                 }
13754                 {
13755                         uint32_t _flags_save_string_array = ndr->flags;
13756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13757                         if (r->core_driver_dependencies) {
13758                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->core_driver_dependencies));
13759                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13760                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->core_driver_dependencies));
13761                         }
13762                         ndr->flags = _flags_save_string_array;
13763                 }
13764         }
13765         return NDR_ERR_SUCCESS;
13766 }
13767
13768 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13769 {
13770         uint32_t _ptr_driver_name;
13771         TALLOC_CTX *_mem_save_driver_name_0;
13772         uint32_t _ptr_architecture;
13773         TALLOC_CTX *_mem_save_architecture_0;
13774         uint32_t _ptr_driver_path;
13775         TALLOC_CTX *_mem_save_driver_path_0;
13776         uint32_t _ptr_data_file;
13777         TALLOC_CTX *_mem_save_data_file_0;
13778         uint32_t _ptr_config_file;
13779         TALLOC_CTX *_mem_save_config_file_0;
13780         uint32_t _ptr_help_file;
13781         TALLOC_CTX *_mem_save_help_file_0;
13782         uint32_t _ptr_dependent_files;
13783         TALLOC_CTX *_mem_save_dependent_files_0;
13784         uint32_t _ptr_monitor_name;
13785         TALLOC_CTX *_mem_save_monitor_name_0;
13786         uint32_t _ptr_default_datatype;
13787         TALLOC_CTX *_mem_save_default_datatype_0;
13788         uint32_t _ptr_previous_names;
13789         TALLOC_CTX *_mem_save_previous_names_0;
13790         uint32_t _ptr_manufacturer_name;
13791         TALLOC_CTX *_mem_save_manufacturer_name_0;
13792         uint32_t _ptr_manufacturer_url;
13793         TALLOC_CTX *_mem_save_manufacturer_url_0;
13794         uint32_t _ptr_hardware_id;
13795         TALLOC_CTX *_mem_save_hardware_id_0;
13796         uint32_t _ptr_provider;
13797         TALLOC_CTX *_mem_save_provider_0;
13798         uint32_t _ptr_print_processor;
13799         TALLOC_CTX *_mem_save_print_processor_0;
13800         uint32_t _ptr_vendor_setup;
13801         TALLOC_CTX *_mem_save_vendor_setup_0;
13802         uint32_t _ptr_color_profiles;
13803         TALLOC_CTX *_mem_save_color_profiles_0;
13804         uint32_t _ptr_inf_path;
13805         TALLOC_CTX *_mem_save_inf_path_0;
13806         uint32_t _ptr_core_driver_dependencies;
13807         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13808         if (ndr_flags & NDR_SCALARS) {
13809                 NDR_CHECK(ndr_pull_align(ndr, 8));
13810                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13811                 {
13812                         uint32_t _flags_save_string = ndr->flags;
13813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13814                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13815                         if (_ptr_driver_name) {
13816                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13817                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13818                         } else {
13819                                 r->driver_name = NULL;
13820                         }
13821                         ndr->flags = _flags_save_string;
13822                 }
13823                 {
13824                         uint32_t _flags_save_string = ndr->flags;
13825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13826                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13827                         if (_ptr_architecture) {
13828                                 NDR_PULL_ALLOC(ndr, r->architecture);
13829                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13830                         } else {
13831                                 r->architecture = NULL;
13832                         }
13833                         ndr->flags = _flags_save_string;
13834                 }
13835                 {
13836                         uint32_t _flags_save_string = ndr->flags;
13837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13838                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13839                         if (_ptr_driver_path) {
13840                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13841                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13842                         } else {
13843                                 r->driver_path = NULL;
13844                         }
13845                         ndr->flags = _flags_save_string;
13846                 }
13847                 {
13848                         uint32_t _flags_save_string = ndr->flags;
13849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13850                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13851                         if (_ptr_data_file) {
13852                                 NDR_PULL_ALLOC(ndr, r->data_file);
13853                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13854                         } else {
13855                                 r->data_file = NULL;
13856                         }
13857                         ndr->flags = _flags_save_string;
13858                 }
13859                 {
13860                         uint32_t _flags_save_string = ndr->flags;
13861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13862                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13863                         if (_ptr_config_file) {
13864                                 NDR_PULL_ALLOC(ndr, r->config_file);
13865                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13866                         } else {
13867                                 r->config_file = NULL;
13868                         }
13869                         ndr->flags = _flags_save_string;
13870                 }
13871                 {
13872                         uint32_t _flags_save_string = ndr->flags;
13873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13874                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13875                         if (_ptr_help_file) {
13876                                 NDR_PULL_ALLOC(ndr, r->help_file);
13877                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13878                         } else {
13879                                 r->help_file = NULL;
13880                         }
13881                         ndr->flags = _flags_save_string;
13882                 }
13883                 {
13884                         uint32_t _flags_save_string_array = ndr->flags;
13885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13886                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13887                         if (_ptr_dependent_files) {
13888                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13889                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13890                         } else {
13891                                 r->dependent_files = NULL;
13892                         }
13893                         ndr->flags = _flags_save_string_array;
13894                 }
13895                 {
13896                         uint32_t _flags_save_string = ndr->flags;
13897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13898                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13899                         if (_ptr_monitor_name) {
13900                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13901                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13902                         } else {
13903                                 r->monitor_name = NULL;
13904                         }
13905                         ndr->flags = _flags_save_string;
13906                 }
13907                 {
13908                         uint32_t _flags_save_string = ndr->flags;
13909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13911                         if (_ptr_default_datatype) {
13912                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13914                         } else {
13915                                 r->default_datatype = NULL;
13916                         }
13917                         ndr->flags = _flags_save_string;
13918                 }
13919                 {
13920                         uint32_t _flags_save_string_array = ndr->flags;
13921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13923                         if (_ptr_previous_names) {
13924                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13926                         } else {
13927                                 r->previous_names = NULL;
13928                         }
13929                         ndr->flags = _flags_save_string_array;
13930                 }
13931                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13932                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13933                 {
13934                         uint32_t _flags_save_string = ndr->flags;
13935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13936                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13937                         if (_ptr_manufacturer_name) {
13938                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13939                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13940                         } else {
13941                                 r->manufacturer_name = NULL;
13942                         }
13943                         ndr->flags = _flags_save_string;
13944                 }
13945                 {
13946                         uint32_t _flags_save_string = ndr->flags;
13947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13948                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13949                         if (_ptr_manufacturer_url) {
13950                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13951                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13952                         } else {
13953                                 r->manufacturer_url = NULL;
13954                         }
13955                         ndr->flags = _flags_save_string;
13956                 }
13957                 {
13958                         uint32_t _flags_save_string = ndr->flags;
13959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13960                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13961                         if (_ptr_hardware_id) {
13962                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13963                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13964                         } else {
13965                                 r->hardware_id = NULL;
13966                         }
13967                         ndr->flags = _flags_save_string;
13968                 }
13969                 {
13970                         uint32_t _flags_save_string = ndr->flags;
13971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13972                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13973                         if (_ptr_provider) {
13974                                 NDR_PULL_ALLOC(ndr, r->provider);
13975                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13976                         } else {
13977                                 r->provider = NULL;
13978                         }
13979                         ndr->flags = _flags_save_string;
13980                 }
13981                 {
13982                         uint32_t _flags_save_string = ndr->flags;
13983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13984                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13985                         if (_ptr_print_processor) {
13986                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13987                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13988                         } else {
13989                                 r->print_processor = NULL;
13990                         }
13991                         ndr->flags = _flags_save_string;
13992                 }
13993                 {
13994                         uint32_t _flags_save_string = ndr->flags;
13995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13996                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13997                         if (_ptr_vendor_setup) {
13998                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13999                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
14000                         } else {
14001                                 r->vendor_setup = NULL;
14002                         }
14003                         ndr->flags = _flags_save_string;
14004                 }
14005                 {
14006                         uint32_t _flags_save_string_array = ndr->flags;
14007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14008                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
14009                         if (_ptr_color_profiles) {
14010                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
14011                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
14012                         } else {
14013                                 r->color_profiles = NULL;
14014                         }
14015                         ndr->flags = _flags_save_string_array;
14016                 }
14017                 {
14018                         uint32_t _flags_save_string = ndr->flags;
14019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14020                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
14021                         if (_ptr_inf_path) {
14022                                 NDR_PULL_ALLOC(ndr, r->inf_path);
14023                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
14024                         } else {
14025                                 r->inf_path = NULL;
14026                         }
14027                         ndr->flags = _flags_save_string;
14028                 }
14029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
14030                 {
14031                         uint32_t _flags_save_string_array = ndr->flags;
14032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14033                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
14034                         if (_ptr_core_driver_dependencies) {
14035                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
14036                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
14037                         } else {
14038                                 r->core_driver_dependencies = NULL;
14039                         }
14040                         ndr->flags = _flags_save_string_array;
14041                 }
14042                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
14043                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
14044                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
14045         }
14046         if (ndr_flags & NDR_BUFFERS) {
14047                 {
14048                         uint32_t _flags_save_string = ndr->flags;
14049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14050                         if (r->driver_name) {
14051                                 uint32_t _relative_save_offset;
14052                                 _relative_save_offset = ndr->offset;
14053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
14054                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14055                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
14056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
14057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
14058                                 if (ndr->offset > ndr->relative_highest_offset) {
14059                                         ndr->relative_highest_offset = ndr->offset;
14060                                 }
14061                                 ndr->offset = _relative_save_offset;
14062                         }
14063                         ndr->flags = _flags_save_string;
14064                 }
14065                 {
14066                         uint32_t _flags_save_string = ndr->flags;
14067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14068                         if (r->architecture) {
14069                                 uint32_t _relative_save_offset;
14070                                 _relative_save_offset = ndr->offset;
14071                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
14072                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
14073                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
14074                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
14075                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
14076                                 if (ndr->offset > ndr->relative_highest_offset) {
14077                                         ndr->relative_highest_offset = ndr->offset;
14078                                 }
14079                                 ndr->offset = _relative_save_offset;
14080                         }
14081                         ndr->flags = _flags_save_string;
14082                 }
14083                 {
14084                         uint32_t _flags_save_string = ndr->flags;
14085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14086                         if (r->driver_path) {
14087                                 uint32_t _relative_save_offset;
14088                                 _relative_save_offset = ndr->offset;
14089                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
14090                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14091                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
14092                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
14093                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
14094                                 if (ndr->offset > ndr->relative_highest_offset) {
14095                                         ndr->relative_highest_offset = ndr->offset;
14096                                 }
14097                                 ndr->offset = _relative_save_offset;
14098                         }
14099                         ndr->flags = _flags_save_string;
14100                 }
14101                 {
14102                         uint32_t _flags_save_string = ndr->flags;
14103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14104                         if (r->data_file) {
14105                                 uint32_t _relative_save_offset;
14106                                 _relative_save_offset = ndr->offset;
14107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
14108                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14109                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
14110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
14111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
14112                                 if (ndr->offset > ndr->relative_highest_offset) {
14113                                         ndr->relative_highest_offset = ndr->offset;
14114                                 }
14115                                 ndr->offset = _relative_save_offset;
14116                         }
14117                         ndr->flags = _flags_save_string;
14118                 }
14119                 {
14120                         uint32_t _flags_save_string = ndr->flags;
14121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14122                         if (r->config_file) {
14123                                 uint32_t _relative_save_offset;
14124                                 _relative_save_offset = ndr->offset;
14125                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
14126                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14127                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
14128                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
14129                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
14130                                 if (ndr->offset > ndr->relative_highest_offset) {
14131                                         ndr->relative_highest_offset = ndr->offset;
14132                                 }
14133                                 ndr->offset = _relative_save_offset;
14134                         }
14135                         ndr->flags = _flags_save_string;
14136                 }
14137                 {
14138                         uint32_t _flags_save_string = ndr->flags;
14139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14140                         if (r->help_file) {
14141                                 uint32_t _relative_save_offset;
14142                                 _relative_save_offset = ndr->offset;
14143                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
14144                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14145                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
14146                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
14147                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
14148                                 if (ndr->offset > ndr->relative_highest_offset) {
14149                                         ndr->relative_highest_offset = ndr->offset;
14150                                 }
14151                                 ndr->offset = _relative_save_offset;
14152                         }
14153                         ndr->flags = _flags_save_string;
14154                 }
14155                 {
14156                         uint32_t _flags_save_string_array = ndr->flags;
14157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14158                         if (r->dependent_files) {
14159                                 uint32_t _relative_save_offset;
14160                                 _relative_save_offset = ndr->offset;
14161                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
14162                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
14163                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
14164                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
14165                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
14166                                 if (ndr->offset > ndr->relative_highest_offset) {
14167                                         ndr->relative_highest_offset = ndr->offset;
14168                                 }
14169                                 ndr->offset = _relative_save_offset;
14170                         }
14171                         ndr->flags = _flags_save_string_array;
14172                 }
14173                 {
14174                         uint32_t _flags_save_string = ndr->flags;
14175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14176                         if (r->monitor_name) {
14177                                 uint32_t _relative_save_offset;
14178                                 _relative_save_offset = ndr->offset;
14179                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14180                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14181                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14182                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14183                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14184                                 if (ndr->offset > ndr->relative_highest_offset) {
14185                                         ndr->relative_highest_offset = ndr->offset;
14186                                 }
14187                                 ndr->offset = _relative_save_offset;
14188                         }
14189                         ndr->flags = _flags_save_string;
14190                 }
14191                 {
14192                         uint32_t _flags_save_string = ndr->flags;
14193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14194                         if (r->default_datatype) {
14195                                 uint32_t _relative_save_offset;
14196                                 _relative_save_offset = ndr->offset;
14197                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
14198                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14199                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
14200                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
14201                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
14202                                 if (ndr->offset > ndr->relative_highest_offset) {
14203                                         ndr->relative_highest_offset = ndr->offset;
14204                                 }
14205                                 ndr->offset = _relative_save_offset;
14206                         }
14207                         ndr->flags = _flags_save_string;
14208                 }
14209                 {
14210                         uint32_t _flags_save_string_array = ndr->flags;
14211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14212                         if (r->previous_names) {
14213                                 uint32_t _relative_save_offset;
14214                                 _relative_save_offset = ndr->offset;
14215                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
14216                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
14217                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
14218                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
14219                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
14220                                 if (ndr->offset > ndr->relative_highest_offset) {
14221                                         ndr->relative_highest_offset = ndr->offset;
14222                                 }
14223                                 ndr->offset = _relative_save_offset;
14224                         }
14225                         ndr->flags = _flags_save_string_array;
14226                 }
14227                 {
14228                         uint32_t _flags_save_string = ndr->flags;
14229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14230                         if (r->manufacturer_name) {
14231                                 uint32_t _relative_save_offset;
14232                                 _relative_save_offset = ndr->offset;
14233                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
14234                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14235                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
14236                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
14237                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
14238                                 if (ndr->offset > ndr->relative_highest_offset) {
14239                                         ndr->relative_highest_offset = ndr->offset;
14240                                 }
14241                                 ndr->offset = _relative_save_offset;
14242                         }
14243                         ndr->flags = _flags_save_string;
14244                 }
14245                 {
14246                         uint32_t _flags_save_string = ndr->flags;
14247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14248                         if (r->manufacturer_url) {
14249                                 uint32_t _relative_save_offset;
14250                                 _relative_save_offset = ndr->offset;
14251                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
14252                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
14253                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
14254                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
14255                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
14256                                 if (ndr->offset > ndr->relative_highest_offset) {
14257                                         ndr->relative_highest_offset = ndr->offset;
14258                                 }
14259                                 ndr->offset = _relative_save_offset;
14260                         }
14261                         ndr->flags = _flags_save_string;
14262                 }
14263                 {
14264                         uint32_t _flags_save_string = ndr->flags;
14265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14266                         if (r->hardware_id) {
14267                                 uint32_t _relative_save_offset;
14268                                 _relative_save_offset = ndr->offset;
14269                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
14270                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14271                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
14272                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
14273                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
14274                                 if (ndr->offset > ndr->relative_highest_offset) {
14275                                         ndr->relative_highest_offset = ndr->offset;
14276                                 }
14277                                 ndr->offset = _relative_save_offset;
14278                         }
14279                         ndr->flags = _flags_save_string;
14280                 }
14281                 {
14282                         uint32_t _flags_save_string = ndr->flags;
14283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14284                         if (r->provider) {
14285                                 uint32_t _relative_save_offset;
14286                                 _relative_save_offset = ndr->offset;
14287                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
14288                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
14289                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
14290                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
14291                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
14292                                 if (ndr->offset > ndr->relative_highest_offset) {
14293                                         ndr->relative_highest_offset = ndr->offset;
14294                                 }
14295                                 ndr->offset = _relative_save_offset;
14296                         }
14297                         ndr->flags = _flags_save_string;
14298                 }
14299                 {
14300                         uint32_t _flags_save_string = ndr->flags;
14301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14302                         if (r->print_processor) {
14303                                 uint32_t _relative_save_offset;
14304                                 _relative_save_offset = ndr->offset;
14305                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
14306                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
14307                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
14308                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
14309                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
14310                                 if (ndr->offset > ndr->relative_highest_offset) {
14311                                         ndr->relative_highest_offset = ndr->offset;
14312                                 }
14313                                 ndr->offset = _relative_save_offset;
14314                         }
14315                         ndr->flags = _flags_save_string;
14316                 }
14317                 {
14318                         uint32_t _flags_save_string = ndr->flags;
14319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14320                         if (r->vendor_setup) {
14321                                 uint32_t _relative_save_offset;
14322                                 _relative_save_offset = ndr->offset;
14323                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14324                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14325                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14326                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14327                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14328                                 if (ndr->offset > ndr->relative_highest_offset) {
14329                                         ndr->relative_highest_offset = ndr->offset;
14330                                 }
14331                                 ndr->offset = _relative_save_offset;
14332                         }
14333                         ndr->flags = _flags_save_string;
14334                 }
14335                 {
14336                         uint32_t _flags_save_string_array = ndr->flags;
14337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14338                         if (r->color_profiles) {
14339                                 uint32_t _relative_save_offset;
14340                                 _relative_save_offset = ndr->offset;
14341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14342                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14343                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14344                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14346                                 if (ndr->offset > ndr->relative_highest_offset) {
14347                                         ndr->relative_highest_offset = ndr->offset;
14348                                 }
14349                                 ndr->offset = _relative_save_offset;
14350                         }
14351                         ndr->flags = _flags_save_string_array;
14352                 }
14353                 {
14354                         uint32_t _flags_save_string = ndr->flags;
14355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14356                         if (r->inf_path) {
14357                                 uint32_t _relative_save_offset;
14358                                 _relative_save_offset = ndr->offset;
14359                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14360                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14361                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14362                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14363                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14364                                 if (ndr->offset > ndr->relative_highest_offset) {
14365                                         ndr->relative_highest_offset = ndr->offset;
14366                                 }
14367                                 ndr->offset = _relative_save_offset;
14368                         }
14369                         ndr->flags = _flags_save_string;
14370                 }
14371                 {
14372                         uint32_t _flags_save_string_array = ndr->flags;
14373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14374                         if (r->core_driver_dependencies) {
14375                                 uint32_t _relative_save_offset;
14376                                 _relative_save_offset = ndr->offset;
14377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14378                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14379                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14380                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14382                                 if (ndr->offset > ndr->relative_highest_offset) {
14383                                         ndr->relative_highest_offset = ndr->offset;
14384                                 }
14385                                 ndr->offset = _relative_save_offset;
14386                         }
14387                         ndr->flags = _flags_save_string_array;
14388                 }
14389         }
14390         return NDR_ERR_SUCCESS;
14391 }
14392
14393 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14394 {
14395         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14396         ndr->depth++;
14397         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14398         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14399         ndr->depth++;
14400         if (r->driver_name) {
14401                 ndr_print_string(ndr, "driver_name", r->driver_name);
14402         }
14403         ndr->depth--;
14404         ndr_print_ptr(ndr, "architecture", r->architecture);
14405         ndr->depth++;
14406         if (r->architecture) {
14407                 ndr_print_string(ndr, "architecture", r->architecture);
14408         }
14409         ndr->depth--;
14410         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14411         ndr->depth++;
14412         if (r->driver_path) {
14413                 ndr_print_string(ndr, "driver_path", r->driver_path);
14414         }
14415         ndr->depth--;
14416         ndr_print_ptr(ndr, "data_file", r->data_file);
14417         ndr->depth++;
14418         if (r->data_file) {
14419                 ndr_print_string(ndr, "data_file", r->data_file);
14420         }
14421         ndr->depth--;
14422         ndr_print_ptr(ndr, "config_file", r->config_file);
14423         ndr->depth++;
14424         if (r->config_file) {
14425                 ndr_print_string(ndr, "config_file", r->config_file);
14426         }
14427         ndr->depth--;
14428         ndr_print_ptr(ndr, "help_file", r->help_file);
14429         ndr->depth++;
14430         if (r->help_file) {
14431                 ndr_print_string(ndr, "help_file", r->help_file);
14432         }
14433         ndr->depth--;
14434         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14435         ndr->depth++;
14436         if (r->dependent_files) {
14437                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14438         }
14439         ndr->depth--;
14440         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14441         ndr->depth++;
14442         if (r->monitor_name) {
14443                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14444         }
14445         ndr->depth--;
14446         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14447         ndr->depth++;
14448         if (r->default_datatype) {
14449                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14450         }
14451         ndr->depth--;
14452         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14453         ndr->depth++;
14454         if (r->previous_names) {
14455                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14456         }
14457         ndr->depth--;
14458         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14459         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14460         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14461         ndr->depth++;
14462         if (r->manufacturer_name) {
14463                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14464         }
14465         ndr->depth--;
14466         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14467         ndr->depth++;
14468         if (r->manufacturer_url) {
14469                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14470         }
14471         ndr->depth--;
14472         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14473         ndr->depth++;
14474         if (r->hardware_id) {
14475                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14476         }
14477         ndr->depth--;
14478         ndr_print_ptr(ndr, "provider", r->provider);
14479         ndr->depth++;
14480         if (r->provider) {
14481                 ndr_print_string(ndr, "provider", r->provider);
14482         }
14483         ndr->depth--;
14484         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14485         ndr->depth++;
14486         if (r->print_processor) {
14487                 ndr_print_string(ndr, "print_processor", r->print_processor);
14488         }
14489         ndr->depth--;
14490         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14491         ndr->depth++;
14492         if (r->vendor_setup) {
14493                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14494         }
14495         ndr->depth--;
14496         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14497         ndr->depth++;
14498         if (r->color_profiles) {
14499                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14500         }
14501         ndr->depth--;
14502         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14503         ndr->depth++;
14504         if (r->inf_path) {
14505                 ndr_print_string(ndr, "inf_path", r->inf_path);
14506         }
14507         ndr->depth--;
14508         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14509         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14510         ndr->depth++;
14511         if (r->core_driver_dependencies) {
14512                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14513         }
14514         ndr->depth--;
14515         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14516         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14517         ndr->depth--;
14518 }
14519
14520 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14521 {
14522         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14523 }
14524
14525 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14526 {
14527         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14528         return NDR_ERR_SUCCESS;
14529 }
14530
14531 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14532 {
14533         uint32_t v;
14534         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14535         *r = v;
14536         return NDR_ERR_SUCCESS;
14537 }
14538
14539 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14540 {
14541         const char *val = NULL;
14542
14543         switch (r) {
14544                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14545                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14546                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14547                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14548                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14549         }
14550         ndr_print_enum(ndr, name, "ENUM", val, r);
14551 }
14552
14553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14554 {
14555         if (ndr_flags & NDR_SCALARS) {
14556                 NDR_CHECK(ndr_push_align(ndr, 5));
14557                 {
14558                         uint32_t _flags_save_string = ndr->flags;
14559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14560                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14561                         ndr->flags = _flags_save_string;
14562                 }
14563                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14565                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14566         }
14567         if (ndr_flags & NDR_BUFFERS) {
14568                 {
14569                         uint32_t _flags_save_string = ndr->flags;
14570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14571                         if (r->file_name) {
14572                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_name));
14573                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14574                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_name));
14575                         }
14576                         ndr->flags = _flags_save_string;
14577                 }
14578         }
14579         return NDR_ERR_SUCCESS;
14580 }
14581
14582 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14583 {
14584         uint32_t _ptr_file_name;
14585         TALLOC_CTX *_mem_save_file_name_0;
14586         if (ndr_flags & NDR_SCALARS) {
14587                 NDR_CHECK(ndr_pull_align(ndr, 5));
14588                 {
14589                         uint32_t _flags_save_string = ndr->flags;
14590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14591                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14592                         if (_ptr_file_name) {
14593                                 NDR_PULL_ALLOC(ndr, r->file_name);
14594                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14595                         } else {
14596                                 r->file_name = NULL;
14597                         }
14598                         ndr->flags = _flags_save_string;
14599                 }
14600                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14602                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14603         }
14604         if (ndr_flags & NDR_BUFFERS) {
14605                 {
14606                         uint32_t _flags_save_string = ndr->flags;
14607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14608                         if (r->file_name) {
14609                                 uint32_t _relative_save_offset;
14610                                 _relative_save_offset = ndr->offset;
14611                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14612                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14613                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14614                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14615                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14616                                 if (ndr->offset > ndr->relative_highest_offset) {
14617                                         ndr->relative_highest_offset = ndr->offset;
14618                                 }
14619                                 ndr->offset = _relative_save_offset;
14620                         }
14621                         ndr->flags = _flags_save_string;
14622                 }
14623         }
14624         return NDR_ERR_SUCCESS;
14625 }
14626
14627 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14628 {
14629         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14630         ndr->depth++;
14631         ndr_print_ptr(ndr, "file_name", r->file_name);
14632         ndr->depth++;
14633         if (r->file_name) {
14634                 ndr_print_string(ndr, "file_name", r->file_name);
14635         }
14636         ndr->depth--;
14637         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14638         ndr_print_uint32(ndr, "file_version", r->file_version);
14639         ndr->depth--;
14640 }
14641
14642 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14643 {
14644         uint32_t cntr_file_info_1;
14645         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14646         ndr->depth++;
14647         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14648         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14649         ndr->depth++;
14650         if (r->driver_name) {
14651                 ndr_print_string(ndr, "driver_name", r->driver_name);
14652         }
14653         ndr->depth--;
14654         ndr_print_ptr(ndr, "architecture", r->architecture);
14655         ndr->depth++;
14656         if (r->architecture) {
14657                 ndr_print_string(ndr, "architecture", r->architecture);
14658         }
14659         ndr->depth--;
14660         ndr_print_ptr(ndr, "file_info", r->file_info);
14661         ndr->depth++;
14662         if (r->file_info) {
14663                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14664                 ndr->depth++;
14665                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14666                         char *idx_1=NULL;
14667                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14668                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14669                                 free(idx_1);
14670                         }
14671                 }
14672                 ndr->depth--;
14673         }
14674         ndr->depth--;
14675         ndr_print_uint32(ndr, "file_count", r->file_count);
14676         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14677         ndr->depth++;
14678         if (r->monitor_name) {
14679                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14680         }
14681         ndr->depth--;
14682         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14683         ndr->depth++;
14684         if (r->default_datatype) {
14685                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14686         }
14687         ndr->depth--;
14688         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14689         ndr->depth++;
14690         if (r->previous_names) {
14691                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14692         }
14693         ndr->depth--;
14694         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14695         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14696         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14697         ndr->depth++;
14698         if (r->manufacturer_name) {
14699                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14700         }
14701         ndr->depth--;
14702         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14703         ndr->depth++;
14704         if (r->manufacturer_url) {
14705                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14706         }
14707         ndr->depth--;
14708         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14709         ndr->depth++;
14710         if (r->hardware_id) {
14711                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14712         }
14713         ndr->depth--;
14714         ndr_print_ptr(ndr, "provider", r->provider);
14715         ndr->depth++;
14716         if (r->provider) {
14717                 ndr_print_string(ndr, "provider", r->provider);
14718         }
14719         ndr->depth--;
14720         ndr->depth--;
14721 }
14722
14723 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14724 {
14725         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14726 }
14727
14728 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14729 {
14730         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14731         if (ndr_flags & NDR_SCALARS) {
14732                 int level = ndr_push_get_switch_value(ndr, r);
14733                 NDR_CHECK(ndr_push_union_align(ndr, 8));
14734                 switch (level) {
14735                         case 1: {
14736                                 NDR_CHECK(ndr_push_align(ndr, 5));
14737                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14738                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14739                         break; }
14740
14741                         case 2: {
14742                                 NDR_CHECK(ndr_push_align(ndr, 5));
14743                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14744                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14745                         break; }
14746
14747                         case 3: {
14748                                 NDR_CHECK(ndr_push_align(ndr, 5));
14749                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14750                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14751                         break; }
14752
14753                         case 4: {
14754                                 NDR_CHECK(ndr_push_align(ndr, 5));
14755                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14756                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14757                         break; }
14758
14759                         case 5: {
14760                                 NDR_CHECK(ndr_push_align(ndr, 5));
14761                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14762                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14763                         break; }
14764
14765                         case 6: {
14766                                 NDR_CHECK(ndr_push_align(ndr, 8));
14767                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14768                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14769                         break; }
14770
14771                         case 7: {
14772                                 NDR_CHECK(ndr_push_align(ndr, 5));
14773                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14774                                 NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14775                         break; }
14776
14777                         case 8: {
14778                                 NDR_CHECK(ndr_push_align(ndr, 8));
14779                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14780                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14781                         break; }
14782
14783                         case 101: {
14784                                 NDR_CHECK(ndr_push_align(ndr, 8));
14785                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14786                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14787                         break; }
14788
14789                         default: {
14790                         break; }
14791
14792                 }
14793         }
14794         if (ndr_flags & NDR_BUFFERS) {
14795                 int level = ndr_push_get_switch_value(ndr, r);
14796                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14797                 switch (level) {
14798                         case 1:
14799                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14800                         break;
14801
14802                         case 2:
14803                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14804                         break;
14805
14806                         case 3:
14807                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14808                         break;
14809
14810                         case 4:
14811                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14812                         break;
14813
14814                         case 5:
14815                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14816                         break;
14817
14818                         case 6:
14819                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14820                         break;
14821
14822                         case 7:
14823                                 NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14824                         break;
14825
14826                         case 8:
14827                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14828                         break;
14829
14830                         case 101:
14831                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14832                         break;
14833
14834                         default:
14835                         break;
14836
14837                 }
14838         }
14839         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14840         return NDR_ERR_SUCCESS;
14841 }
14842
14843 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14844 {
14845         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14846         int level;
14847         level = ndr_pull_get_switch_value(ndr, r);
14848         if (ndr_flags & NDR_SCALARS) {
14849                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14850                 switch (level) {
14851                         case 1: {
14852                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14853                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14854                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14855                         break; }
14856
14857                         case 2: {
14858                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14859                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14860                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14861                         break; }
14862
14863                         case 3: {
14864                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14865                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14866                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14867                         break; }
14868
14869                         case 4: {
14870                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14871                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14872                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14873                         break; }
14874
14875                         case 5: {
14876                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14877                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14878                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14879                         break; }
14880
14881                         case 6: {
14882                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14883                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14884                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14885                         break; }
14886
14887                         case 7: {
14888                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14889                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14890                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14891                         break; }
14892
14893                         case 8: {
14894                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14895                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14896                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14897                         break; }
14898
14899                         case 101: {
14900                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14901                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14902                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14903                         break; }
14904
14905                         default: {
14906                         break; }
14907
14908                 }
14909         }
14910         if (ndr_flags & NDR_BUFFERS) {
14911                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14912                 switch (level) {
14913                         case 1:
14914                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14915                         break;
14916
14917                         case 2:
14918                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14919                         break;
14920
14921                         case 3:
14922                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14923                         break;
14924
14925                         case 4:
14926                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14927                         break;
14928
14929                         case 5:
14930                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14931                         break;
14932
14933                         case 6:
14934                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14935                         break;
14936
14937                         case 7:
14938                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14939                         break;
14940
14941                         case 8:
14942                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14943                         break;
14944
14945                         case 101:
14946                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14947                         break;
14948
14949                         default:
14950                         break;
14951
14952                 }
14953         }
14954         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14955         return NDR_ERR_SUCCESS;
14956 }
14957
14958 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14959 {
14960         int level;
14961         level = ndr_print_get_switch_value(ndr, r);
14962         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14963         switch (level) {
14964                 case 1:
14965                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14966                 break;
14967
14968                 case 2:
14969                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14970                 break;
14971
14972                 case 3:
14973                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14974                 break;
14975
14976                 case 4:
14977                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14978                 break;
14979
14980                 case 5:
14981                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14982                 break;
14983
14984                 case 6:
14985                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14986                 break;
14987
14988                 case 7:
14989                         ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
14990                 break;
14991
14992                 case 8:
14993                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14994                 break;
14995
14996                 case 101:
14997                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14998                 break;
14999
15000                 default:
15001                 break;
15002
15003         }
15004 }
15005
15006 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15007 {
15008         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
15009 }
15010
15011 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
15012 {
15013         if (ndr_flags & NDR_SCALARS) {
15014                 NDR_CHECK(ndr_push_align(ndr, 4));
15015                 {
15016                         uint32_t _flags_save_string = ndr->flags;
15017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15018                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15019                         ndr->flags = _flags_save_string;
15020                 }
15021                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15022         }
15023         if (ndr_flags & NDR_BUFFERS) {
15024         }
15025         return NDR_ERR_SUCCESS;
15026 }
15027
15028 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
15029 {
15030         if (ndr_flags & NDR_SCALARS) {
15031                 NDR_CHECK(ndr_pull_align(ndr, 4));
15032                 {
15033                         uint32_t _flags_save_string = ndr->flags;
15034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15035                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15036                         ndr->flags = _flags_save_string;
15037                 }
15038                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15039         }
15040         if (ndr_flags & NDR_BUFFERS) {
15041         }
15042         return NDR_ERR_SUCCESS;
15043 }
15044
15045 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
15046 {
15047         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
15048         ndr->depth++;
15049         ndr_print_string(ndr, "directory_name", r->directory_name);
15050         ndr->depth--;
15051 }
15052
15053 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15054 {
15055         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
15056 }
15057
15058 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
15059 {
15060         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15061         if (ndr_flags & NDR_SCALARS) {
15062                 int level = ndr_push_get_switch_value(ndr, r);
15063                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15064                 switch (level) {
15065                         case 1: {
15066                                 NDR_CHECK(ndr_push_align(ndr, 4));
15067                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15068                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15069                         break; }
15070
15071                         default: {
15072                                 NDR_CHECK(ndr_push_align(ndr, 4));
15073                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15074                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15075                         break; }
15076
15077                 }
15078         }
15079         if (ndr_flags & NDR_BUFFERS) {
15080                 int level = ndr_push_get_switch_value(ndr, r);
15081                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15082                 switch (level) {
15083                         case 1:
15084                         break;
15085
15086                         default:
15087                         break;
15088
15089                 }
15090         }
15091         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15092         return NDR_ERR_SUCCESS;
15093 }
15094
15095 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
15096 {
15097         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15098         int level;
15099         level = ndr_pull_get_switch_value(ndr, r);
15100         if (ndr_flags & NDR_SCALARS) {
15101                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15102                 switch (level) {
15103                         case 1: {
15104                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15105                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15106                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15107                         break; }
15108
15109                         default: {
15110                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15111                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15112                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15113                         break; }
15114
15115                 }
15116         }
15117         if (ndr_flags & NDR_BUFFERS) {
15118                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15119                 switch (level) {
15120                         case 1:
15121                         break;
15122
15123                         default:
15124                         break;
15125
15126                 }
15127         }
15128         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15129         return NDR_ERR_SUCCESS;
15130 }
15131
15132 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
15133 {
15134         int level;
15135         level = ndr_print_get_switch_value(ndr, r);
15136         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
15137         switch (level) {
15138                 case 1:
15139                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15140                 break;
15141
15142                 default:
15143                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15144                 break;
15145
15146         }
15147 }
15148
15149 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15150 {
15151         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
15152 }
15153
15154 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
15155 {
15156         if (ndr_flags & NDR_SCALARS) {
15157                 NDR_CHECK(ndr_push_align(ndr, 5));
15158                 {
15159                         uint32_t _flags_save_string = ndr->flags;
15160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15161                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
15162                         ndr->flags = _flags_save_string;
15163                 }
15164                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15165         }
15166         if (ndr_flags & NDR_BUFFERS) {
15167                 {
15168                         uint32_t _flags_save_string = ndr->flags;
15169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15170                         if (r->print_processor_name) {
15171                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor_name));
15172                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
15173                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor_name));
15174                         }
15175                         ndr->flags = _flags_save_string;
15176                 }
15177         }
15178         return NDR_ERR_SUCCESS;
15179 }
15180
15181 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
15182 {
15183         uint32_t _ptr_print_processor_name;
15184         TALLOC_CTX *_mem_save_print_processor_name_0;
15185         if (ndr_flags & NDR_SCALARS) {
15186                 NDR_CHECK(ndr_pull_align(ndr, 5));
15187                 {
15188                         uint32_t _flags_save_string = ndr->flags;
15189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
15191                         if (_ptr_print_processor_name) {
15192                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
15193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
15194                         } else {
15195                                 r->print_processor_name = NULL;
15196                         }
15197                         ndr->flags = _flags_save_string;
15198                 }
15199                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15200         }
15201         if (ndr_flags & NDR_BUFFERS) {
15202                 {
15203                         uint32_t _flags_save_string = ndr->flags;
15204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15205                         if (r->print_processor_name) {
15206                                 uint32_t _relative_save_offset;
15207                                 _relative_save_offset = ndr->offset;
15208                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
15209                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15210                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
15211                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
15212                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
15213                                 if (ndr->offset > ndr->relative_highest_offset) {
15214                                         ndr->relative_highest_offset = ndr->offset;
15215                                 }
15216                                 ndr->offset = _relative_save_offset;
15217                         }
15218                         ndr->flags = _flags_save_string;
15219                 }
15220         }
15221         return NDR_ERR_SUCCESS;
15222 }
15223
15224 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
15225 {
15226         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
15227         ndr->depth++;
15228         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
15229         ndr->depth++;
15230         if (r->print_processor_name) {
15231                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
15232         }
15233         ndr->depth--;
15234         ndr->depth--;
15235 }
15236
15237 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15238 {
15239         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
15240 }
15241
15242 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
15243 {
15244         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15245         if (ndr_flags & NDR_SCALARS) {
15246                 int level = ndr_push_get_switch_value(ndr, r);
15247                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15248                 switch (level) {
15249                         case 1: {
15250                                 NDR_CHECK(ndr_push_align(ndr, 5));
15251                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15252                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15253                         break; }
15254
15255                         default: {
15256                         break; }
15257
15258                 }
15259         }
15260         if (ndr_flags & NDR_BUFFERS) {
15261                 int level = ndr_push_get_switch_value(ndr, r);
15262                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15263                 switch (level) {
15264                         case 1:
15265                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15266                         break;
15267
15268                         default:
15269                         break;
15270
15271                 }
15272         }
15273         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15274         return NDR_ERR_SUCCESS;
15275 }
15276
15277 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
15278 {
15279         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15280         int level;
15281         level = ndr_pull_get_switch_value(ndr, r);
15282         if (ndr_flags & NDR_SCALARS) {
15283                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15284                 switch (level) {
15285                         case 1: {
15286                                 NDR_CHECK(ndr_pull_align(ndr, 5));
15287                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15288                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15289                         break; }
15290
15291                         default: {
15292                         break; }
15293
15294                 }
15295         }
15296         if (ndr_flags & NDR_BUFFERS) {
15297                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15298                 switch (level) {
15299                         case 1:
15300                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15301                         break;
15302
15303                         default:
15304                         break;
15305
15306                 }
15307         }
15308         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15309         return NDR_ERR_SUCCESS;
15310 }
15311
15312 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
15313 {
15314         int level;
15315         level = ndr_print_get_switch_value(ndr, r);
15316         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
15317         switch (level) {
15318                 case 1:
15319                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
15320                 break;
15321
15322                 default:
15323                 break;
15324
15325         }
15326 }
15327
15328 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15329 {
15330         if (ndr_flags & NDR_SCALARS) {
15331                 NDR_CHECK(ndr_push_align(ndr, 4));
15332                 {
15333                         uint32_t _flags_save_string = ndr->flags;
15334                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15335                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15336                         ndr->flags = _flags_save_string;
15337                 }
15338                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15339         }
15340         if (ndr_flags & NDR_BUFFERS) {
15341         }
15342         return NDR_ERR_SUCCESS;
15343 }
15344
15345 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15346 {
15347         if (ndr_flags & NDR_SCALARS) {
15348                 NDR_CHECK(ndr_pull_align(ndr, 4));
15349                 {
15350                         uint32_t _flags_save_string = ndr->flags;
15351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15352                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15353                         ndr->flags = _flags_save_string;
15354                 }
15355                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15356         }
15357         if (ndr_flags & NDR_BUFFERS) {
15358         }
15359         return NDR_ERR_SUCCESS;
15360 }
15361
15362 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15363 {
15364         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15365         ndr->depth++;
15366         ndr_print_string(ndr, "directory_name", r->directory_name);
15367         ndr->depth--;
15368 }
15369
15370 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15371 {
15372         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15373 }
15374
15375 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15376 {
15377         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15378         if (ndr_flags & NDR_SCALARS) {
15379                 int level = ndr_push_get_switch_value(ndr, r);
15380                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15381                 switch (level) {
15382                         case 1: {
15383                                 NDR_CHECK(ndr_push_align(ndr, 4));
15384                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15385                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15386                         break; }
15387
15388                         default: {
15389                                 NDR_CHECK(ndr_push_align(ndr, 4));
15390                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15391                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15392                         break; }
15393
15394                 }
15395         }
15396         if (ndr_flags & NDR_BUFFERS) {
15397                 int level = ndr_push_get_switch_value(ndr, r);
15398                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15399                 switch (level) {
15400                         case 1:
15401                         break;
15402
15403                         default:
15404                         break;
15405
15406                 }
15407         }
15408         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15409         return NDR_ERR_SUCCESS;
15410 }
15411
15412 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15413 {
15414         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15415         int level;
15416         level = ndr_pull_get_switch_value(ndr, r);
15417         if (ndr_flags & NDR_SCALARS) {
15418                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15419                 switch (level) {
15420                         case 1: {
15421                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15422                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15423                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15424                         break; }
15425
15426                         default: {
15427                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15428                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15429                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15430                         break; }
15431
15432                 }
15433         }
15434         if (ndr_flags & NDR_BUFFERS) {
15435                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15436                 switch (level) {
15437                         case 1:
15438                         break;
15439
15440                         default:
15441                         break;
15442
15443                 }
15444         }
15445         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15446         return NDR_ERR_SUCCESS;
15447 }
15448
15449 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15450 {
15451         int level;
15452         level = ndr_print_get_switch_value(ndr, r);
15453         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15454         switch (level) {
15455                 case 1:
15456                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15457                 break;
15458
15459                 default:
15460                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15461                 break;
15462
15463         }
15464 }
15465
15466 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15467 {
15468         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15469 }
15470
15471 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15472 {
15473         if (ndr_flags & NDR_SCALARS) {
15474                 NDR_CHECK(ndr_push_align(ndr, 5));
15475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15476                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15478                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15479         }
15480         if (ndr_flags & NDR_BUFFERS) {
15481                 if (r->document_name) {
15482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15485                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15486                 }
15487                 if (r->output_file) {
15488                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15490                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15491                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15492                 }
15493                 if (r->datatype) {
15494                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15495                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15496                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15497                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15498                 }
15499         }
15500         return NDR_ERR_SUCCESS;
15501 }
15502
15503 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15504 {
15505         uint32_t _ptr_document_name;
15506         TALLOC_CTX *_mem_save_document_name_0;
15507         uint32_t _ptr_output_file;
15508         TALLOC_CTX *_mem_save_output_file_0;
15509         uint32_t _ptr_datatype;
15510         TALLOC_CTX *_mem_save_datatype_0;
15511         if (ndr_flags & NDR_SCALARS) {
15512                 NDR_CHECK(ndr_pull_align(ndr, 5));
15513                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15514                 if (_ptr_document_name) {
15515                         NDR_PULL_ALLOC(ndr, r->document_name);
15516                 } else {
15517                         r->document_name = NULL;
15518                 }
15519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15520                 if (_ptr_output_file) {
15521                         NDR_PULL_ALLOC(ndr, r->output_file);
15522                 } else {
15523                         r->output_file = NULL;
15524                 }
15525                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15526                 if (_ptr_datatype) {
15527                         NDR_PULL_ALLOC(ndr, r->datatype);
15528                 } else {
15529                         r->datatype = NULL;
15530                 }
15531                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15532         }
15533         if (ndr_flags & NDR_BUFFERS) {
15534                 if (r->document_name) {
15535                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15536                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15539                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15540                                 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));
15541                         }
15542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15545                 }
15546                 if (r->output_file) {
15547                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15548                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15550                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15551                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15552                                 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));
15553                         }
15554                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15555                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15557                 }
15558                 if (r->datatype) {
15559                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15560                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15561                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15562                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15563                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15564                                 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));
15565                         }
15566                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15567                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15569                 }
15570         }
15571         return NDR_ERR_SUCCESS;
15572 }
15573
15574 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15575 {
15576         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15577         ndr->depth++;
15578         ndr_print_ptr(ndr, "document_name", r->document_name);
15579         ndr->depth++;
15580         if (r->document_name) {
15581                 ndr_print_string(ndr, "document_name", r->document_name);
15582         }
15583         ndr->depth--;
15584         ndr_print_ptr(ndr, "output_file", r->output_file);
15585         ndr->depth++;
15586         if (r->output_file) {
15587                 ndr_print_string(ndr, "output_file", r->output_file);
15588         }
15589         ndr->depth--;
15590         ndr_print_ptr(ndr, "datatype", r->datatype);
15591         ndr->depth++;
15592         if (r->datatype) {
15593                 ndr_print_string(ndr, "datatype", r->datatype);
15594         }
15595         ndr->depth--;
15596         ndr->depth--;
15597 }
15598
15599 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15600 {
15601         if (ndr_flags & NDR_SCALARS) {
15602                 int level = ndr_push_get_switch_value(ndr, r);
15603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15604                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15605                 switch (level) {
15606                         case 1: {
15607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15608                         break; }
15609
15610                         case 2: {
15611                         break; }
15612
15613                         case 3: {
15614                         break; }
15615
15616                         default: {
15617                         break; }
15618
15619                 }
15620         }
15621         if (ndr_flags & NDR_BUFFERS) {
15622                 int level = ndr_push_get_switch_value(ndr, r);
15623                 switch (level) {
15624                         case 1:
15625                                 if (r->info1) {
15626                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15627                                 }
15628                         break;
15629
15630                         case 2:
15631                         break;
15632
15633                         case 3:
15634                         break;
15635
15636                         default:
15637                         break;
15638
15639                 }
15640         }
15641         return NDR_ERR_SUCCESS;
15642 }
15643
15644 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15645 {
15646         int level;
15647         uint32_t _level;
15648         TALLOC_CTX *_mem_save_info1_0;
15649         level = ndr_pull_get_switch_value(ndr, r);
15650         if (ndr_flags & NDR_SCALARS) {
15651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15652                 if (_level != level) {
15653                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15654                 }
15655                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15656                 switch (level) {
15657                         case 1: {
15658                                 uint32_t _ptr_info1;
15659                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15660                                 if (_ptr_info1) {
15661                                         NDR_PULL_ALLOC(ndr, r->info1);
15662                                 } else {
15663                                         r->info1 = NULL;
15664                                 }
15665                         break; }
15666
15667                         case 2: {
15668                         break; }
15669
15670                         case 3: {
15671                         break; }
15672
15673                         default: {
15674                         break; }
15675
15676                 }
15677         }
15678         if (ndr_flags & NDR_BUFFERS) {
15679                 switch (level) {
15680                         case 1:
15681                                 if (r->info1) {
15682                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15683                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15684                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15685                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15686                                 }
15687                         break;
15688
15689                         case 2:
15690                         break;
15691
15692                         case 3:
15693                         break;
15694
15695                         default:
15696                         break;
15697
15698                 }
15699         }
15700         return NDR_ERR_SUCCESS;
15701 }
15702
15703 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15704 {
15705         int level;
15706         level = ndr_print_get_switch_value(ndr, r);
15707         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15708         switch (level) {
15709                 case 1:
15710                         ndr_print_ptr(ndr, "info1", r->info1);
15711                         ndr->depth++;
15712                         if (r->info1) {
15713                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15714                         }
15715                         ndr->depth--;
15716                 break;
15717
15718                 case 2:
15719                 break;
15720
15721                 case 3:
15722                 break;
15723
15724                 default:
15725                 break;
15726
15727         }
15728 }
15729
15730 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15731 {
15732         if (ndr_flags & NDR_SCALARS) {
15733                 NDR_CHECK(ndr_push_align(ndr, 4));
15734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15739                 {
15740                         uint32_t _flags_save_string = ndr->flags;
15741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15742                         {
15743                                 struct ndr_push *_ndr_extra_string;
15744                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15745                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15746                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15747                         }
15748                         ndr->flags = _flags_save_string;
15749                 }
15750                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15751         }
15752         if (ndr_flags & NDR_BUFFERS) {
15753         }
15754         return NDR_ERR_SUCCESS;
15755 }
15756
15757 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15758 {
15759         if (ndr_flags & NDR_SCALARS) {
15760                 NDR_CHECK(ndr_pull_align(ndr, 4));
15761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15766                 {
15767                         uint32_t _flags_save_string = ndr->flags;
15768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15769                         {
15770                                 struct ndr_pull *_ndr_extra_string;
15771                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15772                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15773                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15774                         }
15775                         ndr->flags = _flags_save_string;
15776                 }
15777                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15778         }
15779         if (ndr_flags & NDR_BUFFERS) {
15780         }
15781         return NDR_ERR_SUCCESS;
15782 }
15783
15784 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15785 {
15786         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15787         ndr->depth++;
15788         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);
15789         ndr_print_uint32(ndr, "major", r->major);
15790         ndr_print_uint32(ndr, "minor", r->minor);
15791         ndr_print_uint32(ndr, "build", r->build);
15792         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15793         ndr_print_string(ndr, "extra_string", r->extra_string);
15794         ndr->depth--;
15795 }
15796
15797 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15798 {
15799         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15800 }
15801
15802 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15803 {
15804         if (ndr_flags & NDR_SCALARS) {
15805                 NDR_CHECK(ndr_push_align(ndr, 4));
15806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15811                 {
15812                         uint32_t _flags_save_string = ndr->flags;
15813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15814                         {
15815                                 struct ndr_push *_ndr_extra_string;
15816                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15817                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15818                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15819                         }
15820                         ndr->flags = _flags_save_string;
15821                 }
15822                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15823                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15824                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15825                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15826                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15827                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15828         }
15829         if (ndr_flags & NDR_BUFFERS) {
15830         }
15831         return NDR_ERR_SUCCESS;
15832 }
15833
15834 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15835 {
15836         if (ndr_flags & NDR_SCALARS) {
15837                 NDR_CHECK(ndr_pull_align(ndr, 4));
15838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15843                 {
15844                         uint32_t _flags_save_string = ndr->flags;
15845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15846                         {
15847                                 struct ndr_pull *_ndr_extra_string;
15848                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15849                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15850                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15851                         }
15852                         ndr->flags = _flags_save_string;
15853                 }
15854                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15855                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15856                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15857                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15858                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15859                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15860         }
15861         if (ndr_flags & NDR_BUFFERS) {
15862         }
15863         return NDR_ERR_SUCCESS;
15864 }
15865
15866 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15867 {
15868         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15869         ndr->depth++;
15870         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);
15871         ndr_print_uint32(ndr, "major", r->major);
15872         ndr_print_uint32(ndr, "minor", r->minor);
15873         ndr_print_uint32(ndr, "build", r->build);
15874         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15875         ndr_print_string(ndr, "extra_string", r->extra_string);
15876         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15877         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15878         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15879         ndr_print_uint8(ndr, "product_type", r->product_type);
15880         ndr_print_uint8(ndr, "reserved", r->reserved);
15881         ndr->depth--;
15882 }
15883
15884 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15885 {
15886         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15887 }
15888
15889 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15890 {
15891         if (ndr_flags & NDR_SCALARS) {
15892                 int level = ndr_push_get_switch_value(ndr, r);
15893                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15894                 switch (level) {
15895                         case REG_NONE: {
15896                         break; }
15897
15898                         case REG_SZ: {
15899                                 {
15900                                         uint32_t _flags_save_string = ndr->flags;
15901                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15902                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15903                                         ndr->flags = _flags_save_string;
15904                                 }
15905                         break; }
15906
15907                         case REG_BINARY: {
15908                                 {
15909                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15910                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15911                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15912                                         ndr->flags = _flags_save_DATA_BLOB;
15913                                 }
15914                         break; }
15915
15916                         case REG_DWORD: {
15917                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15918                         break; }
15919
15920                         case REG_MULTI_SZ: {
15921                                 {
15922                                         uint32_t _flags_save_string_array = ndr->flags;
15923                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15924                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15925                                         ndr->flags = _flags_save_string_array;
15926                                 }
15927                         break; }
15928
15929                         default: {
15930                                 {
15931                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15932                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15933                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15934                                         ndr->flags = _flags_save_DATA_BLOB;
15935                                 }
15936                         break; }
15937
15938                 }
15939         }
15940         if (ndr_flags & NDR_BUFFERS) {
15941                 int level = ndr_push_get_switch_value(ndr, r);
15942                 switch (level) {
15943                         case REG_NONE:
15944                         break;
15945
15946                         case REG_SZ:
15947                         break;
15948
15949                         case REG_BINARY:
15950                         break;
15951
15952                         case REG_DWORD:
15953                         break;
15954
15955                         case REG_MULTI_SZ:
15956                         break;
15957
15958                         default:
15959                         break;
15960
15961                 }
15962         }
15963         return NDR_ERR_SUCCESS;
15964 }
15965
15966 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15967 {
15968         int level;
15969         level = ndr_pull_get_switch_value(ndr, r);
15970         if (ndr_flags & NDR_SCALARS) {
15971                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15972                 switch (level) {
15973                         case REG_NONE: {
15974                         break; }
15975
15976                         case REG_SZ: {
15977                                 {
15978                                         uint32_t _flags_save_string = ndr->flags;
15979                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15980                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15981                                         ndr->flags = _flags_save_string;
15982                                 }
15983                         break; }
15984
15985                         case REG_BINARY: {
15986                                 {
15987                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15988                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15989                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15990                                         ndr->flags = _flags_save_DATA_BLOB;
15991                                 }
15992                         break; }
15993
15994                         case REG_DWORD: {
15995                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15996                         break; }
15997
15998                         case REG_MULTI_SZ: {
15999                                 {
16000                                         uint32_t _flags_save_string_array = ndr->flags;
16001                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16002                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
16003                                         ndr->flags = _flags_save_string_array;
16004                                 }
16005                         break; }
16006
16007                         default: {
16008                                 {
16009                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16010                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16011                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
16012                                         ndr->flags = _flags_save_DATA_BLOB;
16013                                 }
16014                         break; }
16015
16016                 }
16017         }
16018         if (ndr_flags & NDR_BUFFERS) {
16019                 switch (level) {
16020                         case REG_NONE:
16021                         break;
16022
16023                         case REG_SZ:
16024                         break;
16025
16026                         case REG_BINARY:
16027                         break;
16028
16029                         case REG_DWORD:
16030                         break;
16031
16032                         case REG_MULTI_SZ:
16033                         break;
16034
16035                         default:
16036                         break;
16037
16038                 }
16039         }
16040         return NDR_ERR_SUCCESS;
16041 }
16042
16043 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
16044 {
16045         int level;
16046         level = ndr_print_get_switch_value(ndr, r);
16047         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
16048         switch (level) {
16049                 case REG_NONE:
16050                 break;
16051
16052                 case REG_SZ:
16053                         ndr_print_string(ndr, "string", r->string);
16054                 break;
16055
16056                 case REG_BINARY:
16057                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
16058                 break;
16059
16060                 case REG_DWORD:
16061                         ndr_print_uint32(ndr, "value", r->value);
16062                 break;
16063
16064                 case REG_MULTI_SZ:
16065                         ndr_print_string_array(ndr, "string_array", r->string_array);
16066                 break;
16067
16068                 default:
16069                         ndr_print_DATA_BLOB(ndr, "data", r->data);
16070                 break;
16071
16072         }
16073 }
16074
16075 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
16076 {
16077         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16078         return NDR_ERR_SUCCESS;
16079 }
16080
16081 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
16082 {
16083         uint32_t v;
16084         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16085         *r = v;
16086         return NDR_ERR_SUCCESS;
16087 }
16088
16089 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
16090 {
16091         const char *val = NULL;
16092
16093         switch (r) {
16094                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
16095                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
16096                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
16097         }
16098         ndr_print_enum(ndr, name, "ENUM", val, r);
16099 }
16100
16101 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
16102 {
16103         if (ndr_flags & NDR_SCALARS) {
16104                 NDR_CHECK(ndr_push_align(ndr, 4));
16105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
16106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
16107                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16108         }
16109         if (ndr_flags & NDR_BUFFERS) {
16110         }
16111         return NDR_ERR_SUCCESS;
16112 }
16113
16114 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
16115 {
16116         if (ndr_flags & NDR_SCALARS) {
16117                 NDR_CHECK(ndr_pull_align(ndr, 4));
16118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
16119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
16120                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16121         }
16122         if (ndr_flags & NDR_BUFFERS) {
16123         }
16124         return NDR_ERR_SUCCESS;
16125 }
16126
16127 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
16128 {
16129         ndr_print_struct(ndr, name, "spoolss_FormSize");
16130         ndr->depth++;
16131         ndr_print_uint32(ndr, "width", r->width);
16132         ndr_print_uint32(ndr, "height", r->height);
16133         ndr->depth--;
16134 }
16135
16136 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
16137 {
16138         if (ndr_flags & NDR_SCALARS) {
16139                 NDR_CHECK(ndr_push_align(ndr, 4));
16140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
16141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
16142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
16143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
16144                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16145         }
16146         if (ndr_flags & NDR_BUFFERS) {
16147         }
16148         return NDR_ERR_SUCCESS;
16149 }
16150
16151 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
16152 {
16153         if (ndr_flags & NDR_SCALARS) {
16154                 NDR_CHECK(ndr_pull_align(ndr, 4));
16155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
16156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
16157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
16158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
16159                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16160         }
16161         if (ndr_flags & NDR_BUFFERS) {
16162         }
16163         return NDR_ERR_SUCCESS;
16164 }
16165
16166 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
16167 {
16168         ndr_print_struct(ndr, name, "spoolss_FormArea");
16169         ndr->depth++;
16170         ndr_print_uint32(ndr, "left", r->left);
16171         ndr_print_uint32(ndr, "top", r->top);
16172         ndr_print_uint32(ndr, "right", r->right);
16173         ndr_print_uint32(ndr, "bottom", r->bottom);
16174         ndr->depth--;
16175 }
16176
16177 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
16178 {
16179         if (ndr_flags & NDR_SCALARS) {
16180                 NDR_CHECK(ndr_push_align(ndr, 5));
16181                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16182                 {
16183                         uint32_t _flags_save_string = ndr->flags;
16184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16185                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16186                         ndr->flags = _flags_save_string;
16187                 }
16188                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16189                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16190                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16191         }
16192         if (ndr_flags & NDR_BUFFERS) {
16193                 {
16194                         uint32_t _flags_save_string = ndr->flags;
16195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16196                         if (r->form_name) {
16197                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16198                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16199                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16200                         }
16201                         ndr->flags = _flags_save_string;
16202                 }
16203         }
16204         return NDR_ERR_SUCCESS;
16205 }
16206
16207 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
16208 {
16209         uint32_t _ptr_form_name;
16210         TALLOC_CTX *_mem_save_form_name_0;
16211         if (ndr_flags & NDR_SCALARS) {
16212                 NDR_CHECK(ndr_pull_align(ndr, 5));
16213                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16214                 {
16215                         uint32_t _flags_save_string = ndr->flags;
16216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16217                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16218                         if (_ptr_form_name) {
16219                                 NDR_PULL_ALLOC(ndr, r->form_name);
16220                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16221                         } else {
16222                                 r->form_name = NULL;
16223                         }
16224                         ndr->flags = _flags_save_string;
16225                 }
16226                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16227                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16228                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16229         }
16230         if (ndr_flags & NDR_BUFFERS) {
16231                 {
16232                         uint32_t _flags_save_string = ndr->flags;
16233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16234                         if (r->form_name) {
16235                                 uint32_t _relative_save_offset;
16236                                 _relative_save_offset = ndr->offset;
16237                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16238                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16239                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16240                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16241                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16242                                 if (ndr->offset > ndr->relative_highest_offset) {
16243                                         ndr->relative_highest_offset = ndr->offset;
16244                                 }
16245                                 ndr->offset = _relative_save_offset;
16246                         }
16247                         ndr->flags = _flags_save_string;
16248                 }
16249         }
16250         return NDR_ERR_SUCCESS;
16251 }
16252
16253 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
16254 {
16255         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
16256         ndr->depth++;
16257         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16258         ndr_print_ptr(ndr, "form_name", r->form_name);
16259         ndr->depth++;
16260         if (r->form_name) {
16261                 ndr_print_string(ndr, "form_name", r->form_name);
16262         }
16263         ndr->depth--;
16264         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16265         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16266         ndr->depth--;
16267 }
16268
16269 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16270 {
16271         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
16272 }
16273
16274 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16275 {
16276         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16277         return NDR_ERR_SUCCESS;
16278 }
16279
16280 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16281 {
16282         uint32_t v;
16283         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16284         *r = v;
16285         return NDR_ERR_SUCCESS;
16286 }
16287
16288 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
16289 {
16290         ndr_print_uint32(ndr, name, r);
16291         ndr->depth++;
16292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
16293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
16294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
16295         ndr->depth--;
16296 }
16297
16298 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
16299 {
16300         if (ndr_flags & NDR_SCALARS) {
16301                 NDR_CHECK(ndr_push_align(ndr, 5));
16302                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16303                 {
16304                         uint32_t _flags_save_string = ndr->flags;
16305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16307                         ndr->flags = _flags_save_string;
16308                 }
16309                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16310                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16311                 {
16312                         uint32_t _flags_save_string = ndr->flags;
16313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
16315                         ndr->flags = _flags_save_string;
16316                 }
16317                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16318                 {
16319                         uint32_t _flags_save_string = ndr->flags;
16320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16321                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
16322                         ndr->flags = _flags_save_string;
16323                 }
16324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16325                 {
16326                         uint32_t _flags_save_string = ndr->flags;
16327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16328                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16329                         ndr->flags = _flags_save_string;
16330                 }
16331                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16332                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16333                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16334         }
16335         if (ndr_flags & NDR_BUFFERS) {
16336                 {
16337                         uint32_t _flags_save_string = ndr->flags;
16338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16339                         if (r->form_name) {
16340                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16341                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16342                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16343                         }
16344                         ndr->flags = _flags_save_string;
16345                 }
16346                 {
16347                         uint32_t _flags_save_string = ndr->flags;
16348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16349                         if (r->keyword) {
16350                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->keyword));
16351                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16352                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->keyword));
16353                         }
16354                         ndr->flags = _flags_save_string;
16355                 }
16356                 {
16357                         uint32_t _flags_save_string = ndr->flags;
16358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16359                         if (r->mui_dll) {
16360                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->mui_dll));
16361                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16362                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->mui_dll));
16363                         }
16364                         ndr->flags = _flags_save_string;
16365                 }
16366                 {
16367                         uint32_t _flags_save_string = ndr->flags;
16368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16369                         if (r->display_name) {
16370                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
16371                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16372                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
16373                         }
16374                         ndr->flags = _flags_save_string;
16375                 }
16376         }
16377         return NDR_ERR_SUCCESS;
16378 }
16379
16380 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16381 {
16382         uint32_t _ptr_form_name;
16383         TALLOC_CTX *_mem_save_form_name_0;
16384         uint32_t _ptr_keyword;
16385         TALLOC_CTX *_mem_save_keyword_0;
16386         uint32_t _ptr_mui_dll;
16387         TALLOC_CTX *_mem_save_mui_dll_0;
16388         uint32_t _ptr_display_name;
16389         TALLOC_CTX *_mem_save_display_name_0;
16390         if (ndr_flags & NDR_SCALARS) {
16391                 NDR_CHECK(ndr_pull_align(ndr, 5));
16392                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16393                 {
16394                         uint32_t _flags_save_string = ndr->flags;
16395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16396                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16397                         if (_ptr_form_name) {
16398                                 NDR_PULL_ALLOC(ndr, r->form_name);
16399                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16400                         } else {
16401                                 r->form_name = NULL;
16402                         }
16403                         ndr->flags = _flags_save_string;
16404                 }
16405                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16406                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16407                 {
16408                         uint32_t _flags_save_string = ndr->flags;
16409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16410                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16411                         if (_ptr_keyword) {
16412                                 NDR_PULL_ALLOC(ndr, r->keyword);
16413                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16414                         } else {
16415                                 r->keyword = NULL;
16416                         }
16417                         ndr->flags = _flags_save_string;
16418                 }
16419                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16420                 {
16421                         uint32_t _flags_save_string = ndr->flags;
16422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16423                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16424                         if (_ptr_mui_dll) {
16425                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16427                         } else {
16428                                 r->mui_dll = NULL;
16429                         }
16430                         ndr->flags = _flags_save_string;
16431                 }
16432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16433                 {
16434                         uint32_t _flags_save_string = ndr->flags;
16435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16436                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16437                         if (_ptr_display_name) {
16438                                 NDR_PULL_ALLOC(ndr, r->display_name);
16439                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16440                         } else {
16441                                 r->display_name = NULL;
16442                         }
16443                         ndr->flags = _flags_save_string;
16444                 }
16445                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16446                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16447                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16448         }
16449         if (ndr_flags & NDR_BUFFERS) {
16450                 {
16451                         uint32_t _flags_save_string = ndr->flags;
16452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16453                         if (r->form_name) {
16454                                 uint32_t _relative_save_offset;
16455                                 _relative_save_offset = ndr->offset;
16456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16457                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16458                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16461                                 if (ndr->offset > ndr->relative_highest_offset) {
16462                                         ndr->relative_highest_offset = ndr->offset;
16463                                 }
16464                                 ndr->offset = _relative_save_offset;
16465                         }
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_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16471                         if (r->keyword) {
16472                                 uint32_t _relative_save_offset;
16473                                 _relative_save_offset = ndr->offset;
16474                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16475                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16476                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16477                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16478                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16479                                 if (ndr->offset > ndr->relative_highest_offset) {
16480                                         ndr->relative_highest_offset = ndr->offset;
16481                                 }
16482                                 ndr->offset = _relative_save_offset;
16483                         }
16484                         ndr->flags = _flags_save_string;
16485                 }
16486                 {
16487                         uint32_t _flags_save_string = ndr->flags;
16488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16489                         if (r->mui_dll) {
16490                                 uint32_t _relative_save_offset;
16491                                 _relative_save_offset = ndr->offset;
16492                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16493                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16494                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16495                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16496                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16497                                 if (ndr->offset > ndr->relative_highest_offset) {
16498                                         ndr->relative_highest_offset = ndr->offset;
16499                                 }
16500                                 ndr->offset = _relative_save_offset;
16501                         }
16502                         ndr->flags = _flags_save_string;
16503                 }
16504                 {
16505                         uint32_t _flags_save_string = ndr->flags;
16506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16507                         if (r->display_name) {
16508                                 uint32_t _relative_save_offset;
16509                                 _relative_save_offset = ndr->offset;
16510                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16511                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16512                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16513                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16514                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16515                                 if (ndr->offset > ndr->relative_highest_offset) {
16516                                         ndr->relative_highest_offset = ndr->offset;
16517                                 }
16518                                 ndr->offset = _relative_save_offset;
16519                         }
16520                         ndr->flags = _flags_save_string;
16521                 }
16522         }
16523         return NDR_ERR_SUCCESS;
16524 }
16525
16526 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16527 {
16528         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16529         ndr->depth++;
16530         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16531         ndr_print_ptr(ndr, "form_name", r->form_name);
16532         ndr->depth++;
16533         if (r->form_name) {
16534                 ndr_print_string(ndr, "form_name", r->form_name);
16535         }
16536         ndr->depth--;
16537         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16538         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16539         ndr_print_ptr(ndr, "keyword", r->keyword);
16540         ndr->depth++;
16541         if (r->keyword) {
16542                 ndr_print_string(ndr, "keyword", r->keyword);
16543         }
16544         ndr->depth--;
16545         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16546         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16547         ndr->depth++;
16548         if (r->mui_dll) {
16549                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16550         }
16551         ndr->depth--;
16552         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16553         ndr_print_ptr(ndr, "display_name", r->display_name);
16554         ndr->depth++;
16555         if (r->display_name) {
16556                 ndr_print_string(ndr, "display_name", r->display_name);
16557         }
16558         ndr->depth--;
16559         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16560         ndr_print_uint16(ndr, "unused", r->unused);
16561         ndr->depth--;
16562 }
16563
16564 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16565 {
16566         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16567 }
16568
16569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16570 {
16571         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16572         if (ndr_flags & NDR_SCALARS) {
16573                 int level = ndr_push_get_switch_value(ndr, r);
16574                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16575                 switch (level) {
16576                         case 1: {
16577                                 NDR_CHECK(ndr_push_align(ndr, 5));
16578                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16579                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16580                         break; }
16581
16582                         case 2: {
16583                                 NDR_CHECK(ndr_push_align(ndr, 5));
16584                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16585                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16586                         break; }
16587
16588                         default: {
16589                         break; }
16590
16591                 }
16592         }
16593         if (ndr_flags & NDR_BUFFERS) {
16594                 int level = ndr_push_get_switch_value(ndr, r);
16595                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16596                 switch (level) {
16597                         case 1:
16598                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16599                         break;
16600
16601                         case 2:
16602                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16603                         break;
16604
16605                         default:
16606                         break;
16607
16608                 }
16609         }
16610         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16611         return NDR_ERR_SUCCESS;
16612 }
16613
16614 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16615 {
16616         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16617         int level;
16618         level = ndr_pull_get_switch_value(ndr, r);
16619         if (ndr_flags & NDR_SCALARS) {
16620                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16621                 switch (level) {
16622                         case 1: {
16623                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16624                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16625                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16626                         break; }
16627
16628                         case 2: {
16629                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16630                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16631                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16632                         break; }
16633
16634                         default: {
16635                         break; }
16636
16637                 }
16638         }
16639         if (ndr_flags & NDR_BUFFERS) {
16640                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16641                 switch (level) {
16642                         case 1:
16643                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16644                         break;
16645
16646                         case 2:
16647                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16648                         break;
16649
16650                         default:
16651                         break;
16652
16653                 }
16654         }
16655         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16656         return NDR_ERR_SUCCESS;
16657 }
16658
16659 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16660 {
16661         int level;
16662         level = ndr_print_get_switch_value(ndr, r);
16663         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16664         switch (level) {
16665                 case 1:
16666                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16667                 break;
16668
16669                 case 2:
16670                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16671                 break;
16672
16673                 default:
16674                 break;
16675
16676         }
16677 }
16678
16679 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16680 {
16681         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16682 }
16683
16684 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16685 {
16686         if (ndr_flags & NDR_SCALARS) {
16687                 NDR_CHECK(ndr_push_align(ndr, 5));
16688                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16690                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16691                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16692                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16693         }
16694         if (ndr_flags & NDR_BUFFERS) {
16695                 if (r->form_name) {
16696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16700                 }
16701         }
16702         return NDR_ERR_SUCCESS;
16703 }
16704
16705 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16706 {
16707         uint32_t _ptr_form_name;
16708         TALLOC_CTX *_mem_save_form_name_0;
16709         if (ndr_flags & NDR_SCALARS) {
16710                 NDR_CHECK(ndr_pull_align(ndr, 5));
16711                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16713                 if (_ptr_form_name) {
16714                         NDR_PULL_ALLOC(ndr, r->form_name);
16715                 } else {
16716                         r->form_name = NULL;
16717                 }
16718                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16719                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16720                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16721         }
16722         if (ndr_flags & NDR_BUFFERS) {
16723                 if (r->form_name) {
16724                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16725                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16726                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16727                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16728                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16729                                 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));
16730                         }
16731                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16732                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16734                 }
16735         }
16736         return NDR_ERR_SUCCESS;
16737 }
16738
16739 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16740 {
16741         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16742         ndr->depth++;
16743         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16744         ndr_print_ptr(ndr, "form_name", r->form_name);
16745         ndr->depth++;
16746         if (r->form_name) {
16747                 ndr_print_string(ndr, "form_name", r->form_name);
16748         }
16749         ndr->depth--;
16750         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16751         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16752         ndr->depth--;
16753 }
16754
16755 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16756 {
16757         if (ndr_flags & NDR_SCALARS) {
16758                 NDR_CHECK(ndr_push_align(ndr, 5));
16759                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16760                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16761                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16762                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16764                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16769                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16770         }
16771         if (ndr_flags & NDR_BUFFERS) {
16772                 if (r->form_name) {
16773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16776                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16777                 }
16778                 if (r->keyword) {
16779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16783                 }
16784                 if (r->mui_dll) {
16785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16787                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16788                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16789                 }
16790                 if (r->display_name) {
16791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16793                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16794                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16795                 }
16796         }
16797         return NDR_ERR_SUCCESS;
16798 }
16799
16800 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16801 {
16802         uint32_t _ptr_form_name;
16803         TALLOC_CTX *_mem_save_form_name_0;
16804         uint32_t _ptr_keyword;
16805         TALLOC_CTX *_mem_save_keyword_0;
16806         uint32_t _ptr_mui_dll;
16807         TALLOC_CTX *_mem_save_mui_dll_0;
16808         uint32_t _ptr_display_name;
16809         TALLOC_CTX *_mem_save_display_name_0;
16810         if (ndr_flags & NDR_SCALARS) {
16811                 NDR_CHECK(ndr_pull_align(ndr, 5));
16812                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16814                 if (_ptr_form_name) {
16815                         NDR_PULL_ALLOC(ndr, r->form_name);
16816                 } else {
16817                         r->form_name = NULL;
16818                 }
16819                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16820                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16822                 if (_ptr_keyword) {
16823                         NDR_PULL_ALLOC(ndr, r->keyword);
16824                 } else {
16825                         r->keyword = NULL;
16826                 }
16827                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16829                 if (_ptr_mui_dll) {
16830                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16831                 } else {
16832                         r->mui_dll = NULL;
16833                 }
16834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16836                 if (_ptr_display_name) {
16837                         NDR_PULL_ALLOC(ndr, r->display_name);
16838                 } else {
16839                         r->display_name = NULL;
16840                 }
16841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16842                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16843         }
16844         if (ndr_flags & NDR_BUFFERS) {
16845                 if (r->form_name) {
16846                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16847                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16848                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16849                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16850                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16851                                 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));
16852                         }
16853                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16854                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16856                 }
16857                 if (r->keyword) {
16858                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16859                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16860                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16861                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16862                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16863                                 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));
16864                         }
16865                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16866                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16867                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16868                 }
16869                 if (r->mui_dll) {
16870                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16871                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16872                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16873                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16874                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16875                                 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));
16876                         }
16877                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16878                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16879                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16880                 }
16881                 if (r->display_name) {
16882                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16883                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16884                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16885                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16886                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16887                                 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));
16888                         }
16889                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16890                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16892                 }
16893         }
16894         return NDR_ERR_SUCCESS;
16895 }
16896
16897 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16898 {
16899         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16900         ndr->depth++;
16901         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16902         ndr_print_ptr(ndr, "form_name", r->form_name);
16903         ndr->depth++;
16904         if (r->form_name) {
16905                 ndr_print_string(ndr, "form_name", r->form_name);
16906         }
16907         ndr->depth--;
16908         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16909         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16910         ndr_print_ptr(ndr, "keyword", r->keyword);
16911         ndr->depth++;
16912         if (r->keyword) {
16913                 ndr_print_string(ndr, "keyword", r->keyword);
16914         }
16915         ndr->depth--;
16916         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16917         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16918         ndr->depth++;
16919         if (r->mui_dll) {
16920                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16921         }
16922         ndr->depth--;
16923         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16924         ndr_print_ptr(ndr, "display_name", r->display_name);
16925         ndr->depth++;
16926         if (r->display_name) {
16927                 ndr_print_string(ndr, "display_name", r->display_name);
16928         }
16929         ndr->depth--;
16930         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16931         ndr->depth--;
16932 }
16933
16934 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16935 {
16936         if (ndr_flags & NDR_SCALARS) {
16937                 int level = ndr_push_get_switch_value(ndr, r);
16938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16939                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16940                 switch (level) {
16941                         case 1: {
16942                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16943                         break; }
16944
16945                         case 2: {
16946                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16947                         break; }
16948
16949                         default:
16950                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16951                 }
16952         }
16953         if (ndr_flags & NDR_BUFFERS) {
16954                 int level = ndr_push_get_switch_value(ndr, r);
16955                 switch (level) {
16956                         case 1:
16957                                 if (r->info1) {
16958                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16959                                 }
16960                         break;
16961
16962                         case 2:
16963                                 if (r->info2) {
16964                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16965                                 }
16966                         break;
16967
16968                         default:
16969                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16970                 }
16971         }
16972         return NDR_ERR_SUCCESS;
16973 }
16974
16975 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16976 {
16977         int level;
16978         uint32_t _level;
16979         TALLOC_CTX *_mem_save_info1_0;
16980         TALLOC_CTX *_mem_save_info2_0;
16981         level = ndr_pull_get_switch_value(ndr, r);
16982         if (ndr_flags & NDR_SCALARS) {
16983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16984                 if (_level != level) {
16985                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16986                 }
16987                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16988                 switch (level) {
16989                         case 1: {
16990                                 uint32_t _ptr_info1;
16991                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16992                                 if (_ptr_info1) {
16993                                         NDR_PULL_ALLOC(ndr, r->info1);
16994                                 } else {
16995                                         r->info1 = NULL;
16996                                 }
16997                         break; }
16998
16999                         case 2: {
17000                                 uint32_t _ptr_info2;
17001                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
17002                                 if (_ptr_info2) {
17003                                         NDR_PULL_ALLOC(ndr, r->info2);
17004                                 } else {
17005                                         r->info2 = NULL;
17006                                 }
17007                         break; }
17008
17009                         default:
17010                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17011                 }
17012         }
17013         if (ndr_flags & NDR_BUFFERS) {
17014                 switch (level) {
17015                         case 1:
17016                                 if (r->info1) {
17017                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
17018                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
17019                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17020                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
17021                                 }
17022                         break;
17023
17024                         case 2:
17025                                 if (r->info2) {
17026                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
17027                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
17028                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17029                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
17030                                 }
17031                         break;
17032
17033                         default:
17034                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17035                 }
17036         }
17037         return NDR_ERR_SUCCESS;
17038 }
17039
17040 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
17041 {
17042         int level;
17043         level = ndr_print_get_switch_value(ndr, r);
17044         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
17045         switch (level) {
17046                 case 1:
17047                         ndr_print_ptr(ndr, "info1", r->info1);
17048                         ndr->depth++;
17049                         if (r->info1) {
17050                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
17051                         }
17052                         ndr->depth--;
17053                 break;
17054
17055                 case 2:
17056                         ndr_print_ptr(ndr, "info2", r->info2);
17057                         ndr->depth++;
17058                         if (r->info2) {
17059                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
17060                         }
17061                         ndr->depth--;
17062                 break;
17063
17064                 default:
17065                         ndr_print_bad_level(ndr, name, level);
17066         }
17067 }
17068
17069 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
17070 {
17071         if (ndr_flags & NDR_SCALARS) {
17072                 NDR_CHECK(ndr_push_align(ndr, 5));
17073                 {
17074                         uint32_t _flags_save_string = ndr->flags;
17075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17076                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17077                         ndr->flags = _flags_save_string;
17078                 }
17079                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17080         }
17081         if (ndr_flags & NDR_BUFFERS) {
17082                 {
17083                         uint32_t _flags_save_string = ndr->flags;
17084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17085                         if (r->port_name) {
17086                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17087                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17088                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17089                         }
17090                         ndr->flags = _flags_save_string;
17091                 }
17092         }
17093         return NDR_ERR_SUCCESS;
17094 }
17095
17096 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
17097 {
17098         uint32_t _ptr_port_name;
17099         TALLOC_CTX *_mem_save_port_name_0;
17100         if (ndr_flags & NDR_SCALARS) {
17101                 NDR_CHECK(ndr_pull_align(ndr, 5));
17102                 {
17103                         uint32_t _flags_save_string = ndr->flags;
17104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17105                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17106                         if (_ptr_port_name) {
17107                                 NDR_PULL_ALLOC(ndr, r->port_name);
17108                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17109                         } else {
17110                                 r->port_name = NULL;
17111                         }
17112                         ndr->flags = _flags_save_string;
17113                 }
17114                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17115         }
17116         if (ndr_flags & NDR_BUFFERS) {
17117                 {
17118                         uint32_t _flags_save_string = ndr->flags;
17119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17120                         if (r->port_name) {
17121                                 uint32_t _relative_save_offset;
17122                                 _relative_save_offset = ndr->offset;
17123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17124                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17125                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17126                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17128                                 if (ndr->offset > ndr->relative_highest_offset) {
17129                                         ndr->relative_highest_offset = ndr->offset;
17130                                 }
17131                                 ndr->offset = _relative_save_offset;
17132                         }
17133                         ndr->flags = _flags_save_string;
17134                 }
17135         }
17136         return NDR_ERR_SUCCESS;
17137 }
17138
17139 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
17140 {
17141         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
17142         ndr->depth++;
17143         ndr_print_ptr(ndr, "port_name", r->port_name);
17144         ndr->depth++;
17145         if (r->port_name) {
17146                 ndr_print_string(ndr, "port_name", r->port_name);
17147         }
17148         ndr->depth--;
17149         ndr->depth--;
17150 }
17151
17152 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17153 {
17154         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
17155 }
17156
17157 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17158 {
17159         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17160         return NDR_ERR_SUCCESS;
17161 }
17162
17163 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17164 {
17165         uint32_t v;
17166         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17167         *r = v;
17168         return NDR_ERR_SUCCESS;
17169 }
17170
17171 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
17172 {
17173         ndr_print_uint32(ndr, name, r);
17174         ndr->depth++;
17175         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
17176         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
17177         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
17178         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
17179         ndr->depth--;
17180 }
17181
17182 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
17183 {
17184         if (ndr_flags & NDR_SCALARS) {
17185                 NDR_CHECK(ndr_push_align(ndr, 5));
17186                 {
17187                         uint32_t _flags_save_string = ndr->flags;
17188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17189                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17190                         ndr->flags = _flags_save_string;
17191                 }
17192                 {
17193                         uint32_t _flags_save_string = ndr->flags;
17194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17195                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17196                         ndr->flags = _flags_save_string;
17197                 }
17198                 {
17199                         uint32_t _flags_save_string = ndr->flags;
17200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17201                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
17202                         ndr->flags = _flags_save_string;
17203                 }
17204                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
17205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
17206                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17207         }
17208         if (ndr_flags & NDR_BUFFERS) {
17209                 {
17210                         uint32_t _flags_save_string = ndr->flags;
17211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17212                         if (r->port_name) {
17213                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17214                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17215                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17216                         }
17217                         ndr->flags = _flags_save_string;
17218                 }
17219                 {
17220                         uint32_t _flags_save_string = ndr->flags;
17221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17222                         if (r->monitor_name) {
17223                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17224                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17225                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17226                         }
17227                         ndr->flags = _flags_save_string;
17228                 }
17229                 {
17230                         uint32_t _flags_save_string = ndr->flags;
17231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17232                         if (r->description) {
17233                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
17234                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
17235                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
17236                         }
17237                         ndr->flags = _flags_save_string;
17238                 }
17239         }
17240         return NDR_ERR_SUCCESS;
17241 }
17242
17243 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
17244 {
17245         uint32_t _ptr_port_name;
17246         TALLOC_CTX *_mem_save_port_name_0;
17247         uint32_t _ptr_monitor_name;
17248         TALLOC_CTX *_mem_save_monitor_name_0;
17249         uint32_t _ptr_description;
17250         TALLOC_CTX *_mem_save_description_0;
17251         if (ndr_flags & NDR_SCALARS) {
17252                 NDR_CHECK(ndr_pull_align(ndr, 5));
17253                 {
17254                         uint32_t _flags_save_string = ndr->flags;
17255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17256                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17257                         if (_ptr_port_name) {
17258                                 NDR_PULL_ALLOC(ndr, r->port_name);
17259                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17260                         } else {
17261                                 r->port_name = NULL;
17262                         }
17263                         ndr->flags = _flags_save_string;
17264                 }
17265                 {
17266                         uint32_t _flags_save_string = ndr->flags;
17267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17268                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17269                         if (_ptr_monitor_name) {
17270                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17271                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17272                         } else {
17273                                 r->monitor_name = NULL;
17274                         }
17275                         ndr->flags = _flags_save_string;
17276                 }
17277                 {
17278                         uint32_t _flags_save_string = ndr->flags;
17279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17280                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
17281                         if (_ptr_description) {
17282                                 NDR_PULL_ALLOC(ndr, r->description);
17283                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
17284                         } else {
17285                                 r->description = NULL;
17286                         }
17287                         ndr->flags = _flags_save_string;
17288                 }
17289                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
17290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
17291                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17292         }
17293         if (ndr_flags & NDR_BUFFERS) {
17294                 {
17295                         uint32_t _flags_save_string = ndr->flags;
17296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17297                         if (r->port_name) {
17298                                 uint32_t _relative_save_offset;
17299                                 _relative_save_offset = ndr->offset;
17300                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17301                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17302                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17303                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17304                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17305                                 if (ndr->offset > ndr->relative_highest_offset) {
17306                                         ndr->relative_highest_offset = ndr->offset;
17307                                 }
17308                                 ndr->offset = _relative_save_offset;
17309                         }
17310                         ndr->flags = _flags_save_string;
17311                 }
17312                 {
17313                         uint32_t _flags_save_string = ndr->flags;
17314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17315                         if (r->monitor_name) {
17316                                 uint32_t _relative_save_offset;
17317                                 _relative_save_offset = ndr->offset;
17318                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17319                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17320                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17321                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17322                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17323                                 if (ndr->offset > ndr->relative_highest_offset) {
17324                                         ndr->relative_highest_offset = ndr->offset;
17325                                 }
17326                                 ndr->offset = _relative_save_offset;
17327                         }
17328                         ndr->flags = _flags_save_string;
17329                 }
17330                 {
17331                         uint32_t _flags_save_string = ndr->flags;
17332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17333                         if (r->description) {
17334                                 uint32_t _relative_save_offset;
17335                                 _relative_save_offset = ndr->offset;
17336                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17337                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17338                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17339                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17340                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17341                                 if (ndr->offset > ndr->relative_highest_offset) {
17342                                         ndr->relative_highest_offset = ndr->offset;
17343                                 }
17344                                 ndr->offset = _relative_save_offset;
17345                         }
17346                         ndr->flags = _flags_save_string;
17347                 }
17348         }
17349         return NDR_ERR_SUCCESS;
17350 }
17351
17352 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17353 {
17354         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17355         ndr->depth++;
17356         ndr_print_ptr(ndr, "port_name", r->port_name);
17357         ndr->depth++;
17358         if (r->port_name) {
17359                 ndr_print_string(ndr, "port_name", r->port_name);
17360         }
17361         ndr->depth--;
17362         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17363         ndr->depth++;
17364         if (r->monitor_name) {
17365                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17366         }
17367         ndr->depth--;
17368         ndr_print_ptr(ndr, "description", r->description);
17369         ndr->depth++;
17370         if (r->description) {
17371                 ndr_print_string(ndr, "description", r->description);
17372         }
17373         ndr->depth--;
17374         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17375         ndr_print_uint32(ndr, "reserved", r->reserved);
17376         ndr->depth--;
17377 }
17378
17379 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17380 {
17381         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17382 }
17383
17384 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17385 {
17386         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17387         return NDR_ERR_SUCCESS;
17388 }
17389
17390 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17391 {
17392         uint32_t v;
17393         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17394         *r = v;
17395         return NDR_ERR_SUCCESS;
17396 }
17397
17398 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17399 {
17400         const char *val = NULL;
17401
17402         switch (r) {
17403                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17404                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17405                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17406                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17407                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17408                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17409                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17410                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17411                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17412                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17413                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17414                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17415                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17416         }
17417         ndr_print_enum(ndr, name, "ENUM", val, r);
17418 }
17419
17420 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17421 {
17422         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17423         return NDR_ERR_SUCCESS;
17424 }
17425
17426 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17427 {
17428         uint32_t v;
17429         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17430         *r = v;
17431         return NDR_ERR_SUCCESS;
17432 }
17433
17434 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17435 {
17436         const char *val = NULL;
17437
17438         switch (r) {
17439                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17440                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17441                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17442         }
17443         ndr_print_enum(ndr, name, "ENUM", val, r);
17444 }
17445
17446 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17447 {
17448         if (ndr_flags & NDR_SCALARS) {
17449                 NDR_CHECK(ndr_push_align(ndr, 5));
17450                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17451                 {
17452                         uint32_t _flags_save_string = ndr->flags;
17453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17454                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17455                         ndr->flags = _flags_save_string;
17456                 }
17457                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17458                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17459         }
17460         if (ndr_flags & NDR_BUFFERS) {
17461                 {
17462                         uint32_t _flags_save_string = ndr->flags;
17463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17464                         if (r->status_string) {
17465                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->status_string));
17466                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17467                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->status_string));
17468                         }
17469                         ndr->flags = _flags_save_string;
17470                 }
17471         }
17472         return NDR_ERR_SUCCESS;
17473 }
17474
17475 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17476 {
17477         uint32_t _ptr_status_string;
17478         TALLOC_CTX *_mem_save_status_string_0;
17479         if (ndr_flags & NDR_SCALARS) {
17480                 NDR_CHECK(ndr_pull_align(ndr, 5));
17481                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17482                 {
17483                         uint32_t _flags_save_string = ndr->flags;
17484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17485                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17486                         if (_ptr_status_string) {
17487                                 NDR_PULL_ALLOC(ndr, r->status_string);
17488                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17489                         } else {
17490                                 r->status_string = NULL;
17491                         }
17492                         ndr->flags = _flags_save_string;
17493                 }
17494                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17495                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17496         }
17497         if (ndr_flags & NDR_BUFFERS) {
17498                 {
17499                         uint32_t _flags_save_string = ndr->flags;
17500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17501                         if (r->status_string) {
17502                                 uint32_t _relative_save_offset;
17503                                 _relative_save_offset = ndr->offset;
17504                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17505                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17506                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17507                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17508                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17509                                 if (ndr->offset > ndr->relative_highest_offset) {
17510                                         ndr->relative_highest_offset = ndr->offset;
17511                                 }
17512                                 ndr->offset = _relative_save_offset;
17513                         }
17514                         ndr->flags = _flags_save_string;
17515                 }
17516         }
17517         return NDR_ERR_SUCCESS;
17518 }
17519
17520 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17521 {
17522         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17523         ndr->depth++;
17524         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17525         ndr_print_ptr(ndr, "status_string", r->status_string);
17526         ndr->depth++;
17527         if (r->status_string) {
17528                 ndr_print_string(ndr, "status_string", r->status_string);
17529         }
17530         ndr->depth--;
17531         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17532         ndr->depth--;
17533 }
17534
17535 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17536 {
17537         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17538 }
17539
17540 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17541 {
17542         if (ndr_flags & NDR_SCALARS) {
17543                 NDR_CHECK(ndr_push_align(ndr, 5));
17544                 {
17545                         uint32_t _flags_save_string = ndr->flags;
17546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17548                         ndr->flags = _flags_save_string;
17549                 }
17550                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17551                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17552         }
17553         if (ndr_flags & NDR_BUFFERS) {
17554                 {
17555                         uint32_t _flags_save_string = ndr->flags;
17556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17557                         if (r->port_name) {
17558                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17559                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17560                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17561                         }
17562                         ndr->flags = _flags_save_string;
17563                 }
17564         }
17565         return NDR_ERR_SUCCESS;
17566 }
17567
17568 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17569 {
17570         uint32_t _ptr_port_name;
17571         TALLOC_CTX *_mem_save_port_name_0;
17572         if (ndr_flags & NDR_SCALARS) {
17573                 NDR_CHECK(ndr_pull_align(ndr, 5));
17574                 {
17575                         uint32_t _flags_save_string = ndr->flags;
17576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17577                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17578                         if (_ptr_port_name) {
17579                                 NDR_PULL_ALLOC(ndr, r->port_name);
17580                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17581                         } else {
17582                                 r->port_name = NULL;
17583                         }
17584                         ndr->flags = _flags_save_string;
17585                 }
17586                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17587                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17588         }
17589         if (ndr_flags & NDR_BUFFERS) {
17590                 {
17591                         uint32_t _flags_save_string = ndr->flags;
17592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17593                         if (r->port_name) {
17594                                 uint32_t _relative_save_offset;
17595                                 _relative_save_offset = ndr->offset;
17596                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17597                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17598                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17599                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17600                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17601                                 if (ndr->offset > ndr->relative_highest_offset) {
17602                                         ndr->relative_highest_offset = ndr->offset;
17603                                 }
17604                                 ndr->offset = _relative_save_offset;
17605                         }
17606                         ndr->flags = _flags_save_string;
17607                 }
17608         }
17609         return NDR_ERR_SUCCESS;
17610 }
17611
17612 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17613 {
17614         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17615         ndr->depth++;
17616         ndr_print_ptr(ndr, "port_name", r->port_name);
17617         ndr->depth++;
17618         if (r->port_name) {
17619                 ndr_print_string(ndr, "port_name", r->port_name);
17620         }
17621         ndr->depth--;
17622         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17623         ndr->depth--;
17624 }
17625
17626 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17627 {
17628         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17629 }
17630
17631 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17632 {
17633         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17634         if (ndr_flags & NDR_SCALARS) {
17635                 int level = ndr_push_get_switch_value(ndr, r);
17636                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17637                 switch (level) {
17638                         case 1: {
17639                                 NDR_CHECK(ndr_push_align(ndr, 5));
17640                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17641                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17642                         break; }
17643
17644                         case 2: {
17645                                 NDR_CHECK(ndr_push_align(ndr, 5));
17646                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17647                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17648                         break; }
17649
17650                         case 3: {
17651                                 NDR_CHECK(ndr_push_align(ndr, 5));
17652                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17653                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17654                         break; }
17655
17656                         case 0xff: {
17657                                 NDR_CHECK(ndr_push_align(ndr, 5));
17658                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17659                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17660                         break; }
17661
17662                         default: {
17663                         break; }
17664
17665                 }
17666         }
17667         if (ndr_flags & NDR_BUFFERS) {
17668                 int level = ndr_push_get_switch_value(ndr, r);
17669                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17670                 switch (level) {
17671                         case 1:
17672                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17673                         break;
17674
17675                         case 2:
17676                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17677                         break;
17678
17679                         case 3:
17680                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17681                         break;
17682
17683                         case 0xff:
17684                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17685                         break;
17686
17687                         default:
17688                         break;
17689
17690                 }
17691         }
17692         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17693         return NDR_ERR_SUCCESS;
17694 }
17695
17696 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17697 {
17698         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17699         int level;
17700         level = ndr_pull_get_switch_value(ndr, r);
17701         if (ndr_flags & NDR_SCALARS) {
17702                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17703                 switch (level) {
17704                         case 1: {
17705                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17706                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17707                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17708                         break; }
17709
17710                         case 2: {
17711                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17712                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17713                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17714                         break; }
17715
17716                         case 3: {
17717                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17718                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17719                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17720                         break; }
17721
17722                         case 0xff: {
17723                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17724                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17725                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17726                         break; }
17727
17728                         default: {
17729                         break; }
17730
17731                 }
17732         }
17733         if (ndr_flags & NDR_BUFFERS) {
17734                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17735                 switch (level) {
17736                         case 1:
17737                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17738                         break;
17739
17740                         case 2:
17741                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17742                         break;
17743
17744                         case 3:
17745                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17746                         break;
17747
17748                         case 0xff:
17749                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17750                         break;
17751
17752                         default:
17753                         break;
17754
17755                 }
17756         }
17757         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17758         return NDR_ERR_SUCCESS;
17759 }
17760
17761 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17762 {
17763         int level;
17764         level = ndr_print_get_switch_value(ndr, r);
17765         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17766         switch (level) {
17767                 case 1:
17768                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17769                 break;
17770
17771                 case 2:
17772                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17773                 break;
17774
17775                 case 3:
17776                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17777                 break;
17778
17779                 case 0xff:
17780                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17781                 break;
17782
17783                 default:
17784                 break;
17785
17786         }
17787 }
17788
17789 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17790 {
17791         if (ndr_flags & NDR_SCALARS) {
17792                 NDR_CHECK(ndr_push_align(ndr, 5));
17793                 {
17794                         uint32_t _flags_save_string = ndr->flags;
17795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17796                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17797                         ndr->flags = _flags_save_string;
17798                 }
17799                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17800         }
17801         if (ndr_flags & NDR_BUFFERS) {
17802                 {
17803                         uint32_t _flags_save_string = ndr->flags;
17804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17805                         if (r->monitor_name) {
17806                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17807                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17808                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17809                         }
17810                         ndr->flags = _flags_save_string;
17811                 }
17812         }
17813         return NDR_ERR_SUCCESS;
17814 }
17815
17816 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17817 {
17818         uint32_t _ptr_monitor_name;
17819         TALLOC_CTX *_mem_save_monitor_name_0;
17820         if (ndr_flags & NDR_SCALARS) {
17821                 NDR_CHECK(ndr_pull_align(ndr, 5));
17822                 {
17823                         uint32_t _flags_save_string = ndr->flags;
17824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17825                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17826                         if (_ptr_monitor_name) {
17827                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17828                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17829                         } else {
17830                                 r->monitor_name = NULL;
17831                         }
17832                         ndr->flags = _flags_save_string;
17833                 }
17834                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17835         }
17836         if (ndr_flags & NDR_BUFFERS) {
17837                 {
17838                         uint32_t _flags_save_string = ndr->flags;
17839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17840                         if (r->monitor_name) {
17841                                 uint32_t _relative_save_offset;
17842                                 _relative_save_offset = ndr->offset;
17843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17844                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17845                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17848                                 if (ndr->offset > ndr->relative_highest_offset) {
17849                                         ndr->relative_highest_offset = ndr->offset;
17850                                 }
17851                                 ndr->offset = _relative_save_offset;
17852                         }
17853                         ndr->flags = _flags_save_string;
17854                 }
17855         }
17856         return NDR_ERR_SUCCESS;
17857 }
17858
17859 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17860 {
17861         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17862         ndr->depth++;
17863         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17864         ndr->depth++;
17865         if (r->monitor_name) {
17866                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17867         }
17868         ndr->depth--;
17869         ndr->depth--;
17870 }
17871
17872 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17873 {
17874         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17875 }
17876
17877 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17878 {
17879         if (ndr_flags & NDR_SCALARS) {
17880                 NDR_CHECK(ndr_push_align(ndr, 5));
17881                 {
17882                         uint32_t _flags_save_string = ndr->flags;
17883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17884                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17885                         ndr->flags = _flags_save_string;
17886                 }
17887                 {
17888                         uint32_t _flags_save_string = ndr->flags;
17889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17890                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17891                         ndr->flags = _flags_save_string;
17892                 }
17893                 {
17894                         uint32_t _flags_save_string = ndr->flags;
17895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17896                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17897                         ndr->flags = _flags_save_string;
17898                 }
17899                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17900         }
17901         if (ndr_flags & NDR_BUFFERS) {
17902                 {
17903                         uint32_t _flags_save_string = ndr->flags;
17904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17905                         if (r->monitor_name) {
17906                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17907                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17908                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17909                         }
17910                         ndr->flags = _flags_save_string;
17911                 }
17912                 {
17913                         uint32_t _flags_save_string = ndr->flags;
17914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17915                         if (r->environment) {
17916                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->environment));
17917                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17918                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->environment));
17919                         }
17920                         ndr->flags = _flags_save_string;
17921                 }
17922                 {
17923                         uint32_t _flags_save_string = ndr->flags;
17924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17925                         if (r->dll_name) {
17926                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dll_name));
17927                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17928                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dll_name));
17929                         }
17930                         ndr->flags = _flags_save_string;
17931                 }
17932         }
17933         return NDR_ERR_SUCCESS;
17934 }
17935
17936 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17937 {
17938         uint32_t _ptr_monitor_name;
17939         TALLOC_CTX *_mem_save_monitor_name_0;
17940         uint32_t _ptr_environment;
17941         TALLOC_CTX *_mem_save_environment_0;
17942         uint32_t _ptr_dll_name;
17943         TALLOC_CTX *_mem_save_dll_name_0;
17944         if (ndr_flags & NDR_SCALARS) {
17945                 NDR_CHECK(ndr_pull_align(ndr, 5));
17946                 {
17947                         uint32_t _flags_save_string = ndr->flags;
17948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17949                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17950                         if (_ptr_monitor_name) {
17951                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17952                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17953                         } else {
17954                                 r->monitor_name = NULL;
17955                         }
17956                         ndr->flags = _flags_save_string;
17957                 }
17958                 {
17959                         uint32_t _flags_save_string = ndr->flags;
17960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17961                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17962                         if (_ptr_environment) {
17963                                 NDR_PULL_ALLOC(ndr, r->environment);
17964                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17965                         } else {
17966                                 r->environment = NULL;
17967                         }
17968                         ndr->flags = _flags_save_string;
17969                 }
17970                 {
17971                         uint32_t _flags_save_string = ndr->flags;
17972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17973                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17974                         if (_ptr_dll_name) {
17975                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17976                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17977                         } else {
17978                                 r->dll_name = NULL;
17979                         }
17980                         ndr->flags = _flags_save_string;
17981                 }
17982                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17983         }
17984         if (ndr_flags & NDR_BUFFERS) {
17985                 {
17986                         uint32_t _flags_save_string = ndr->flags;
17987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17988                         if (r->monitor_name) {
17989                                 uint32_t _relative_save_offset;
17990                                 _relative_save_offset = ndr->offset;
17991                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17992                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17993                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17994                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17995                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17996                                 if (ndr->offset > ndr->relative_highest_offset) {
17997                                         ndr->relative_highest_offset = ndr->offset;
17998                                 }
17999                                 ndr->offset = _relative_save_offset;
18000                         }
18001                         ndr->flags = _flags_save_string;
18002                 }
18003                 {
18004                         uint32_t _flags_save_string = ndr->flags;
18005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18006                         if (r->environment) {
18007                                 uint32_t _relative_save_offset;
18008                                 _relative_save_offset = ndr->offset;
18009                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
18010                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18011                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
18012                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
18013                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18014                                 if (ndr->offset > ndr->relative_highest_offset) {
18015                                         ndr->relative_highest_offset = ndr->offset;
18016                                 }
18017                                 ndr->offset = _relative_save_offset;
18018                         }
18019                         ndr->flags = _flags_save_string;
18020                 }
18021                 {
18022                         uint32_t _flags_save_string = ndr->flags;
18023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18024                         if (r->dll_name) {
18025                                 uint32_t _relative_save_offset;
18026                                 _relative_save_offset = ndr->offset;
18027                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
18028                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18029                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
18030                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18031                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
18032                                 if (ndr->offset > ndr->relative_highest_offset) {
18033                                         ndr->relative_highest_offset = ndr->offset;
18034                                 }
18035                                 ndr->offset = _relative_save_offset;
18036                         }
18037                         ndr->flags = _flags_save_string;
18038                 }
18039         }
18040         return NDR_ERR_SUCCESS;
18041 }
18042
18043 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
18044 {
18045         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
18046         ndr->depth++;
18047         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
18048         ndr->depth++;
18049         if (r->monitor_name) {
18050                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
18051         }
18052         ndr->depth--;
18053         ndr_print_ptr(ndr, "environment", r->environment);
18054         ndr->depth++;
18055         if (r->environment) {
18056                 ndr_print_string(ndr, "environment", r->environment);
18057         }
18058         ndr->depth--;
18059         ndr_print_ptr(ndr, "dll_name", r->dll_name);
18060         ndr->depth++;
18061         if (r->dll_name) {
18062                 ndr_print_string(ndr, "dll_name", r->dll_name);
18063         }
18064         ndr->depth--;
18065         ndr->depth--;
18066 }
18067
18068 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
18069 {
18070         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
18071 }
18072
18073 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
18074 {
18075         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18076         if (ndr_flags & NDR_SCALARS) {
18077                 int level = ndr_push_get_switch_value(ndr, r);
18078                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18079                 switch (level) {
18080                         case 1: {
18081                                 NDR_CHECK(ndr_push_align(ndr, 5));
18082                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18083                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18084                         break; }
18085
18086                         case 2: {
18087                                 NDR_CHECK(ndr_push_align(ndr, 5));
18088                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18089                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18090                         break; }
18091
18092                         default: {
18093                         break; }
18094
18095                 }
18096         }
18097         if (ndr_flags & NDR_BUFFERS) {
18098                 int level = ndr_push_get_switch_value(ndr, r);
18099                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18100                 switch (level) {
18101                         case 1:
18102                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18103                         break;
18104
18105                         case 2:
18106                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18107                         break;
18108
18109                         default:
18110                         break;
18111
18112                 }
18113         }
18114         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18115         return NDR_ERR_SUCCESS;
18116 }
18117
18118 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
18119 {
18120         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18121         int level;
18122         level = ndr_pull_get_switch_value(ndr, r);
18123         if (ndr_flags & NDR_SCALARS) {
18124                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18125                 switch (level) {
18126                         case 1: {
18127                                 NDR_CHECK(ndr_pull_align(ndr, 5));
18128                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18129                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18130                         break; }
18131
18132                         case 2: {
18133                                 NDR_CHECK(ndr_pull_align(ndr, 5));
18134                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18135                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18136                         break; }
18137
18138                         default: {
18139                         break; }
18140
18141                 }
18142         }
18143         if (ndr_flags & NDR_BUFFERS) {
18144                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18145                 switch (level) {
18146                         case 1:
18147                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18148                         break;
18149
18150                         case 2:
18151                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18152                         break;
18153
18154                         default:
18155                         break;
18156
18157                 }
18158         }
18159         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18160         return NDR_ERR_SUCCESS;
18161 }
18162
18163 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
18164 {
18165         int level;
18166         level = ndr_print_get_switch_value(ndr, r);
18167         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
18168         switch (level) {
18169                 case 1:
18170                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
18171                 break;
18172
18173                 case 2:
18174                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
18175                 break;
18176
18177                 default:
18178                 break;
18179
18180         }
18181 }
18182
18183 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
18184 {
18185         if (ndr_flags & NDR_SCALARS) {
18186                 NDR_CHECK(ndr_push_align(ndr, 5));
18187                 {
18188                         uint32_t _flags_save_string = ndr->flags;
18189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18190                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
18191                         ndr->flags = _flags_save_string;
18192                 }
18193                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18194         }
18195         if (ndr_flags & NDR_BUFFERS) {
18196                 {
18197                         uint32_t _flags_save_string = ndr->flags;
18198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18199                         if (r->name_array) {
18200                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name_array));
18201                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
18202                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name_array));
18203                         }
18204                         ndr->flags = _flags_save_string;
18205                 }
18206         }
18207         return NDR_ERR_SUCCESS;
18208 }
18209
18210 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
18211 {
18212         uint32_t _ptr_name_array;
18213         TALLOC_CTX *_mem_save_name_array_0;
18214         if (ndr_flags & NDR_SCALARS) {
18215                 NDR_CHECK(ndr_pull_align(ndr, 5));
18216                 {
18217                         uint32_t _flags_save_string = ndr->flags;
18218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
18220                         if (_ptr_name_array) {
18221                                 NDR_PULL_ALLOC(ndr, r->name_array);
18222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
18223                         } else {
18224                                 r->name_array = NULL;
18225                         }
18226                         ndr->flags = _flags_save_string;
18227                 }
18228                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18229         }
18230         if (ndr_flags & NDR_BUFFERS) {
18231                 {
18232                         uint32_t _flags_save_string = ndr->flags;
18233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18234                         if (r->name_array) {
18235                                 uint32_t _relative_save_offset;
18236                                 _relative_save_offset = ndr->offset;
18237                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
18238                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
18239                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
18240                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
18241                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
18242                                 if (ndr->offset > ndr->relative_highest_offset) {
18243                                         ndr->relative_highest_offset = ndr->offset;
18244                                 }
18245                                 ndr->offset = _relative_save_offset;
18246                         }
18247                         ndr->flags = _flags_save_string;
18248                 }
18249         }
18250         return NDR_ERR_SUCCESS;
18251 }
18252
18253 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
18254 {
18255         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
18256         ndr->depth++;
18257         ndr_print_ptr(ndr, "name_array", r->name_array);
18258         ndr->depth++;
18259         if (r->name_array) {
18260                 ndr_print_string(ndr, "name_array", r->name_array);
18261         }
18262         ndr->depth--;
18263         ndr->depth--;
18264 }
18265
18266 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18267 {
18268         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
18269 }
18270
18271 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
18272 {
18273         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18274         if (ndr_flags & NDR_SCALARS) {
18275                 int level = ndr_push_get_switch_value(ndr, r);
18276                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18277                 switch (level) {
18278                         case 1: {
18279                                 NDR_CHECK(ndr_push_align(ndr, 5));
18280                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18281                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18282                         break; }
18283
18284                         default: {
18285                         break; }
18286
18287                 }
18288         }
18289         if (ndr_flags & NDR_BUFFERS) {
18290                 int level = ndr_push_get_switch_value(ndr, r);
18291                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18292                 switch (level) {
18293                         case 1:
18294                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18295                         break;
18296
18297                         default:
18298                         break;
18299
18300                 }
18301         }
18302         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18303         return NDR_ERR_SUCCESS;
18304 }
18305
18306 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
18307 {
18308         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18309         int level;
18310         level = ndr_pull_get_switch_value(ndr, r);
18311         if (ndr_flags & NDR_SCALARS) {
18312                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18313                 switch (level) {
18314                         case 1: {
18315                                 NDR_CHECK(ndr_pull_align(ndr, 5));
18316                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18317                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18318                         break; }
18319
18320                         default: {
18321                         break; }
18322
18323                 }
18324         }
18325         if (ndr_flags & NDR_BUFFERS) {
18326                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18327                 switch (level) {
18328                         case 1:
18329                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18330                         break;
18331
18332                         default:
18333                         break;
18334
18335                 }
18336         }
18337         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18338         return NDR_ERR_SUCCESS;
18339 }
18340
18341 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18342 {
18343         int level;
18344         level = ndr_print_get_switch_value(ndr, r);
18345         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18346         switch (level) {
18347                 case 1:
18348                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18349                 break;
18350
18351                 default:
18352                 break;
18353
18354         }
18355 }
18356
18357 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18358 {
18359         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18360         return NDR_ERR_SUCCESS;
18361 }
18362
18363 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18364 {
18365         uint32_t v;
18366         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18367         *r = v;
18368         return NDR_ERR_SUCCESS;
18369 }
18370
18371 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18372 {
18373         ndr_print_uint32(ndr, name, r);
18374         ndr->depth++;
18375         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18376         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18377         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18378         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18379         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18380         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18381         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18382         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18383         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18384         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18385         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18386         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18387         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18388         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18389         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18390         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18391         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18392         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18393         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18394         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18395         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18396         ndr->depth--;
18397 }
18398
18399 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18400 {
18401         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18402         return NDR_ERR_SUCCESS;
18403 }
18404
18405 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18406 {
18407         uint16_t v;
18408         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18409         *r = v;
18410         return NDR_ERR_SUCCESS;
18411 }
18412
18413 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18414 {
18415         const char *val = NULL;
18416
18417         switch (r) {
18418                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18419                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18420                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18421                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18422                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18423                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18424                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18425                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18426                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18427                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18428                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18429                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18430                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18431                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18432                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18433                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18434                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18435                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18436                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18437                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18438                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18439                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18440                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18441                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18442         }
18443         ndr_print_enum(ndr, name, "ENUM", val, r);
18444 }
18445
18446 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18447 {
18448         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18449         return NDR_ERR_SUCCESS;
18450 }
18451
18452 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18453 {
18454         uint16_t v;
18455         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18456         *r = v;
18457         return NDR_ERR_SUCCESS;
18458 }
18459
18460 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18461 {
18462         const char *val = NULL;
18463
18464         switch (r) {
18465                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18466                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18467                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18468                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18469                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18470                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18471                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18472                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18473                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18474                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18475                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18476                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18477                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18478                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18479                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18480                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18481                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18482                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18483                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18484                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18485                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18486                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18487                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18488                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18489                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18490                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18491                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18492                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18493         }
18494         ndr_print_enum(ndr, name, "ENUM", val, r);
18495 }
18496
18497 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18498 {
18499         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18500         return NDR_ERR_SUCCESS;
18501 }
18502
18503 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18504 {
18505         uint16_t v;
18506         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18507         *r = v;
18508         return NDR_ERR_SUCCESS;
18509 }
18510
18511 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18512 {
18513         const char *val = NULL;
18514
18515         switch (r) {
18516                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18517                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18518         }
18519         ndr_print_enum(ndr, name, "ENUM", val, r);
18520 }
18521
18522 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18523 {
18524         if (ndr_flags & NDR_SCALARS) {
18525                 int level = ndr_push_get_switch_value(ndr, r);
18526                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18527                 switch (level) {
18528                         case PRINTER_NOTIFY_TYPE: {
18529                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18530                         break; }
18531
18532                         case JOB_NOTIFY_TYPE: {
18533                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18534                         break; }
18535
18536                         default: {
18537                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18538                         break; }
18539
18540                 }
18541         }
18542         if (ndr_flags & NDR_BUFFERS) {
18543                 int level = ndr_push_get_switch_value(ndr, r);
18544                 switch (level) {
18545                         case PRINTER_NOTIFY_TYPE:
18546                         break;
18547
18548                         case JOB_NOTIFY_TYPE:
18549                         break;
18550
18551                         default:
18552                         break;
18553
18554                 }
18555         }
18556         return NDR_ERR_SUCCESS;
18557 }
18558
18559 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18560 {
18561         int level;
18562         level = ndr_pull_get_switch_value(ndr, r);
18563         if (ndr_flags & NDR_SCALARS) {
18564                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18565                 switch (level) {
18566                         case PRINTER_NOTIFY_TYPE: {
18567                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18568                         break; }
18569
18570                         case JOB_NOTIFY_TYPE: {
18571                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18572                         break; }
18573
18574                         default: {
18575                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18576                         break; }
18577
18578                 }
18579         }
18580         if (ndr_flags & NDR_BUFFERS) {
18581                 switch (level) {
18582                         case PRINTER_NOTIFY_TYPE:
18583                         break;
18584
18585                         case JOB_NOTIFY_TYPE:
18586                         break;
18587
18588                         default:
18589                         break;
18590
18591                 }
18592         }
18593         return NDR_ERR_SUCCESS;
18594 }
18595
18596 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18597 {
18598         uint32_t cntr_fields_1;
18599         if (ndr_flags & NDR_SCALARS) {
18600                 NDR_CHECK(ndr_push_align(ndr, 5));
18601                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18602                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18607                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18608         }
18609         if (ndr_flags & NDR_BUFFERS) {
18610                 if (r->fields) {
18611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18612                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18613                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18614                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18615                         }
18616                 }
18617         }
18618         return NDR_ERR_SUCCESS;
18619 }
18620
18621 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18622 {
18623         uint32_t _ptr_fields;
18624         uint32_t cntr_fields_1;
18625         TALLOC_CTX *_mem_save_fields_0;
18626         TALLOC_CTX *_mem_save_fields_1;
18627         if (ndr_flags & NDR_SCALARS) {
18628                 NDR_CHECK(ndr_pull_align(ndr, 5));
18629                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18634                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18635                 if (_ptr_fields) {
18636                         NDR_PULL_ALLOC(ndr, r->fields);
18637                 } else {
18638                         r->fields = NULL;
18639                 }
18640                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18641         }
18642         if (ndr_flags & NDR_BUFFERS) {
18643                 if (r->fields) {
18644                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18645                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18646                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18647                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18648                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18649                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18650                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18651                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18652                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18653                         }
18654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18655                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18656                 }
18657                 if (r->fields) {
18658                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18659                 }
18660         }
18661         return NDR_ERR_SUCCESS;
18662 }
18663
18664 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18665 {
18666         uint32_t cntr_fields_1;
18667         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18668         ndr->depth++;
18669         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18670         ndr_print_uint16(ndr, "u1", r->u1);
18671         ndr_print_uint32(ndr, "u2", r->u2);
18672         ndr_print_uint32(ndr, "u3", r->u3);
18673         ndr_print_uint32(ndr, "count", r->count);
18674         ndr_print_ptr(ndr, "fields", r->fields);
18675         ndr->depth++;
18676         if (r->fields) {
18677                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18678                 ndr->depth++;
18679                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18680                         char *idx_1=NULL;
18681                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18682                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18683                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18684                                 free(idx_1);
18685                         }
18686                 }
18687                 ndr->depth--;
18688         }
18689         ndr->depth--;
18690         ndr->depth--;
18691 }
18692
18693 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18694 {
18695         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18696         return NDR_ERR_SUCCESS;
18697 }
18698
18699 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18700 {
18701         uint32_t v;
18702         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18703         *r = v;
18704         return NDR_ERR_SUCCESS;
18705 }
18706
18707 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18708 {
18709         ndr_print_uint32(ndr, name, r);
18710         ndr->depth++;
18711         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18712         ndr->depth--;
18713 }
18714
18715 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18716 {
18717         uint32_t cntr_types_1;
18718         if (ndr_flags & NDR_SCALARS) {
18719                 NDR_CHECK(ndr_push_align(ndr, 5));
18720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18721                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18724                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18725         }
18726         if (ndr_flags & NDR_BUFFERS) {
18727                 if (r->types) {
18728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18729                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18730                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18731                         }
18732                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18733                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18734                         }
18735                 }
18736         }
18737         return NDR_ERR_SUCCESS;
18738 }
18739
18740 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18741 {
18742         uint32_t _ptr_types;
18743         uint32_t cntr_types_1;
18744         TALLOC_CTX *_mem_save_types_0;
18745         TALLOC_CTX *_mem_save_types_1;
18746         if (ndr_flags & NDR_SCALARS) {
18747                 NDR_CHECK(ndr_pull_align(ndr, 5));
18748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18749                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18752                 if (_ptr_types) {
18753                         NDR_PULL_ALLOC(ndr, r->types);
18754                 } else {
18755                         r->types = NULL;
18756                 }
18757                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18758         }
18759         if (ndr_flags & NDR_BUFFERS) {
18760                 if (r->types) {
18761                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18762                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18763                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18764                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18765                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18766                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18767                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18768                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18769                         }
18770                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18771                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18772                         }
18773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18775                 }
18776                 if (r->types) {
18777                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18778                 }
18779         }
18780         return NDR_ERR_SUCCESS;
18781 }
18782
18783 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18784 {
18785         uint32_t cntr_types_1;
18786         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18787         ndr->depth++;
18788         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18789         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18790         ndr_print_uint32(ndr, "count", r->count);
18791         ndr_print_ptr(ndr, "types", r->types);
18792         ndr->depth++;
18793         if (r->types) {
18794                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18795                 ndr->depth++;
18796                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18797                         char *idx_1=NULL;
18798                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18799                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18800                                 free(idx_1);
18801                         }
18802                 }
18803                 ndr->depth--;
18804         }
18805         ndr->depth--;
18806         ndr->depth--;
18807 }
18808
18809 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18810 {
18811         if (ndr_flags & NDR_SCALARS) {
18812                 NDR_CHECK(ndr_push_align(ndr, 5));
18813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18815                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18816         }
18817         if (ndr_flags & NDR_BUFFERS) {
18818                 if (r->string) {
18819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18820                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18821                 }
18822         }
18823         return NDR_ERR_SUCCESS;
18824 }
18825
18826 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18827 {
18828         uint32_t _ptr_string;
18829         TALLOC_CTX *_mem_save_string_0;
18830         if (ndr_flags & NDR_SCALARS) {
18831                 NDR_CHECK(ndr_pull_align(ndr, 5));
18832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18834                 if (_ptr_string) {
18835                         NDR_PULL_ALLOC(ndr, r->string);
18836                 } else {
18837                         r->string = NULL;
18838                 }
18839                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18840         }
18841         if (ndr_flags & NDR_BUFFERS) {
18842                 if (r->string) {
18843                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18844                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18845                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18848                 }
18849                 if (r->string) {
18850                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18851                 }
18852         }
18853         return NDR_ERR_SUCCESS;
18854 }
18855
18856 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18857 {
18858         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18859         ndr->depth++;
18860         ndr_print_uint32(ndr, "size", r->size);
18861         ndr_print_ptr(ndr, "string", r->string);
18862         ndr->depth++;
18863         if (r->string) {
18864                 ndr_print_string(ndr, "string", r->string);
18865         }
18866         ndr->depth--;
18867         ndr->depth--;
18868 }
18869
18870 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18871 {
18872         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18873         return NDR_ERR_SUCCESS;
18874 }
18875
18876 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18877 {
18878         uint32_t v;
18879         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18880         *r = v;
18881         return NDR_ERR_SUCCESS;
18882 }
18883
18884 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18885 {
18886         const char *val = NULL;
18887
18888         switch (r) {
18889                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18890                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18891                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18892                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18893                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18894         }
18895         ndr_print_enum(ndr, name, "ENUM", val, r);
18896 }
18897
18898 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18899 {
18900         if (ndr_flags & NDR_SCALARS) {
18901                 int level = ndr_push_get_switch_value(ndr, r);
18902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18903                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18904                 switch (level) {
18905                         case 1: {
18906                                 uint32_t cntr_integer_0;
18907                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18908                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18909                                 }
18910                         break; }
18911
18912                         case 2: {
18913                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18914                         break; }
18915
18916                         case 3: {
18917                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18918                         break; }
18919
18920                         case 4: {
18921                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18922                         break; }
18923
18924                         case 5: {
18925                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18926                         break; }
18927
18928                         default:
18929                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18930                 }
18931         }
18932         if (ndr_flags & NDR_BUFFERS) {
18933                 int level = ndr_push_get_switch_value(ndr, r);
18934                 switch (level) {
18935                         case 1:
18936                         break;
18937
18938                         case 2:
18939                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18940                         break;
18941
18942                         case 3:
18943                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18944                         break;
18945
18946                         case 4:
18947                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18948                         break;
18949
18950                         case 5:
18951                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18952                         break;
18953
18954                         default:
18955                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18956                 }
18957         }
18958         return NDR_ERR_SUCCESS;
18959 }
18960
18961 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18962 {
18963         int level;
18964         uint32_t _level;
18965         level = ndr_pull_get_switch_value(ndr, r);
18966         if (ndr_flags & NDR_SCALARS) {
18967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18968                 if (_level != level) {
18969                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18970                 }
18971                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18972                 switch (level) {
18973                         case 1: {
18974                                 uint32_t cntr_integer_0;
18975                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18976                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18977                                 }
18978                         break; }
18979
18980                         case 2: {
18981                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18982                         break; }
18983
18984                         case 3: {
18985                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18986                         break; }
18987
18988                         case 4: {
18989                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18990                         break; }
18991
18992                         case 5: {
18993                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18994                         break; }
18995
18996                         default:
18997                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18998                 }
18999         }
19000         if (ndr_flags & NDR_BUFFERS) {
19001                 switch (level) {
19002                         case 1:
19003                         break;
19004
19005                         case 2:
19006                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19007                         break;
19008
19009                         case 3:
19010                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19011                         break;
19012
19013                         case 4:
19014                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19015                         break;
19016
19017                         case 5:
19018                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19019                         break;
19020
19021                         default:
19022                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19023                 }
19024         }
19025         return NDR_ERR_SUCCESS;
19026 }
19027
19028 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
19029 {
19030         int level;
19031         uint32_t cntr_integer_0;
19032         level = ndr_print_get_switch_value(ndr, r);
19033         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
19034         switch (level) {
19035                 case 1:
19036                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
19037                         ndr->depth++;
19038                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
19039                                 char *idx_0=NULL;
19040                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
19041                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
19042                                         free(idx_0);
19043                                 }
19044                         }
19045                         ndr->depth--;
19046                 break;
19047
19048                 case 2:
19049                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
19050                 break;
19051
19052                 case 3:
19053                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
19054                 break;
19055
19056                 case 4:
19057                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
19058                 break;
19059
19060                 case 5:
19061                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
19062                 break;
19063
19064                 default:
19065                         ndr_print_bad_level(ndr, name, level);
19066         }
19067 }
19068
19069 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
19070 {
19071         if (ndr_flags & NDR_SCALARS) {
19072                 NDR_CHECK(ndr_push_align(ndr, 5));
19073                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
19074                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
19075                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19076                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
19077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
19078                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
19079                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19080                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19081         }
19082         if (ndr_flags & NDR_BUFFERS) {
19083                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19084         }
19085         return NDR_ERR_SUCCESS;
19086 }
19087
19088 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
19089 {
19090         if (ndr_flags & NDR_SCALARS) {
19091                 NDR_CHECK(ndr_pull_align(ndr, 5));
19092                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
19093                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
19094                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19095                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
19096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
19097                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
19098                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19099                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19100         }
19101         if (ndr_flags & NDR_BUFFERS) {
19102                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19103         }
19104         return NDR_ERR_SUCCESS;
19105 }
19106
19107 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
19108 {
19109         ndr_print_struct(ndr, name, "spoolss_Notify");
19110         ndr->depth++;
19111         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
19112         ndr_print_set_switch_value(ndr, &r->field, r->type);
19113         ndr_print_spoolss_Field(ndr, "field", &r->field);
19114         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
19115         ndr_print_uint32(ndr, "job_id", r->job_id);
19116         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
19117         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
19118         ndr->depth--;
19119 }
19120
19121 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
19122 {
19123         uint32_t cntr_notifies_0;
19124         if (ndr_flags & NDR_SCALARS) {
19125                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19126                 NDR_CHECK(ndr_push_align(ndr, 5));
19127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
19128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19130                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19131                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19132                 }
19133                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19134         }
19135         if (ndr_flags & NDR_BUFFERS) {
19136                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19137                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19138                 }
19139         }
19140         return NDR_ERR_SUCCESS;
19141 }
19142
19143 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
19144 {
19145         uint32_t cntr_notifies_0;
19146         TALLOC_CTX *_mem_save_notifies_0;
19147         if (ndr_flags & NDR_SCALARS) {
19148                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
19149                 NDR_CHECK(ndr_pull_align(ndr, 5));
19150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19153                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
19154                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19155                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19156                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19157                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19158                 }
19159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19160                 if (r->notifies) {
19161                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
19162                 }
19163                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19164         }
19165         if (ndr_flags & NDR_BUFFERS) {
19166                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19167                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19168                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19169                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19170                 }
19171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19172         }
19173         return NDR_ERR_SUCCESS;
19174 }
19175
19176 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
19177 {
19178         uint32_t cntr_notifies_0;
19179         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
19180         ndr->depth++;
19181         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19182         ndr_print_uint32(ndr, "flags", r->flags);
19183         ndr_print_uint32(ndr, "count", r->count);
19184         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
19185         ndr->depth++;
19186         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
19187                 char *idx_0=NULL;
19188                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
19189                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
19190                         free(idx_0);
19191                 }
19192         }
19193         ndr->depth--;
19194         ndr->depth--;
19195 }
19196
19197 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
19198 {
19199         if (ndr_flags & NDR_SCALARS) {
19200                 int level = ndr_push_get_switch_value(ndr, r);
19201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19202                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19203                 switch (level) {
19204                         case 0: {
19205                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
19206                         break; }
19207
19208                         default:
19209                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19210                 }
19211         }
19212         if (ndr_flags & NDR_BUFFERS) {
19213                 int level = ndr_push_get_switch_value(ndr, r);
19214                 switch (level) {
19215                         case 0:
19216                                 if (r->info0) {
19217                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19218                                 }
19219                         break;
19220
19221                         default:
19222                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19223                 }
19224         }
19225         return NDR_ERR_SUCCESS;
19226 }
19227
19228 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
19229 {
19230         int level;
19231         uint32_t _level;
19232         TALLOC_CTX *_mem_save_info0_0;
19233         level = ndr_pull_get_switch_value(ndr, r);
19234         if (ndr_flags & NDR_SCALARS) {
19235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19236                 if (_level != level) {
19237                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19238                 }
19239                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19240                 switch (level) {
19241                         case 0: {
19242                                 uint32_t _ptr_info0;
19243                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
19244                                 if (_ptr_info0) {
19245                                         NDR_PULL_ALLOC(ndr, r->info0);
19246                                 } else {
19247                                         r->info0 = NULL;
19248                                 }
19249                         break; }
19250
19251                         default:
19252                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19253                 }
19254         }
19255         if (ndr_flags & NDR_BUFFERS) {
19256                 switch (level) {
19257                         case 0:
19258                                 if (r->info0) {
19259                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
19260                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
19261                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19262                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
19263                                 }
19264                         break;
19265
19266                         default:
19267                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19268                 }
19269         }
19270         return NDR_ERR_SUCCESS;
19271 }
19272
19273 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
19274 {
19275         int level;
19276         level = ndr_print_get_switch_value(ndr, r);
19277         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
19278         switch (level) {
19279                 case 0:
19280                         ndr_print_ptr(ndr, "info0", r->info0);
19281                         ndr->depth++;
19282                         if (r->info0) {
19283                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
19284                         }
19285                         ndr->depth--;
19286                 break;
19287
19288                 default:
19289                         ndr_print_bad_level(ndr, name, level);
19290         }
19291 }
19292
19293 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19294 {
19295         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19296         return NDR_ERR_SUCCESS;
19297 }
19298
19299 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19300 {
19301         uint32_t v;
19302         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19303         *r = v;
19304         return NDR_ERR_SUCCESS;
19305 }
19306
19307 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19308 {
19309         ndr_print_uint32(ndr, name, r);
19310         ndr->depth++;
19311         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
19312         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19313         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19314         ndr->depth--;
19315 }
19316
19317 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19318 {
19319         if (ndr_flags & NDR_SCALARS) {
19320                 NDR_CHECK(ndr_push_align(ndr, 5));
19321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19325                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19326                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19327                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19328                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19329         }
19330         if (ndr_flags & NDR_BUFFERS) {
19331                 if (r->client) {
19332                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19333                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19334                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19335                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19336                 }
19337                 if (r->user) {
19338                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19339                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19340                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19342                 }
19343         }
19344         return NDR_ERR_SUCCESS;
19345 }
19346
19347 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19348 {
19349         uint32_t _ptr_client;
19350         TALLOC_CTX *_mem_save_client_0;
19351         uint32_t _ptr_user;
19352         TALLOC_CTX *_mem_save_user_0;
19353         if (ndr_flags & NDR_SCALARS) {
19354                 NDR_CHECK(ndr_pull_align(ndr, 5));
19355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19357                 if (_ptr_client) {
19358                         NDR_PULL_ALLOC(ndr, r->client);
19359                 } else {
19360                         r->client = NULL;
19361                 }
19362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19363                 if (_ptr_user) {
19364                         NDR_PULL_ALLOC(ndr, r->user);
19365                 } else {
19366                         r->user = NULL;
19367                 }
19368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19369                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19370                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19371                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19372                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19373         }
19374         if (ndr_flags & NDR_BUFFERS) {
19375                 if (r->client) {
19376                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19377                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19379                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19380                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19381                                 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));
19382                         }
19383                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19384                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19386                 }
19387                 if (r->user) {
19388                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19389                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19392                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19393                                 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));
19394                         }
19395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19398                 }
19399         }
19400         return NDR_ERR_SUCCESS;
19401 }
19402
19403 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19404 {
19405         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19406         ndr->depth++;
19407         ndr_print_uint32(ndr, "size", r->size);
19408         ndr_print_ptr(ndr, "client", r->client);
19409         ndr->depth++;
19410         if (r->client) {
19411                 ndr_print_string(ndr, "client", r->client);
19412         }
19413         ndr->depth--;
19414         ndr_print_ptr(ndr, "user", r->user);
19415         ndr->depth++;
19416         if (r->user) {
19417                 ndr_print_string(ndr, "user", r->user);
19418         }
19419         ndr->depth--;
19420         ndr_print_uint32(ndr, "build", r->build);
19421         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19422         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19423         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19424         ndr->depth--;
19425 }
19426
19427 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19428 {
19429         if (ndr_flags & NDR_SCALARS) {
19430                 NDR_CHECK(ndr_push_align(ndr, 4));
19431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19432                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19433         }
19434         if (ndr_flags & NDR_BUFFERS) {
19435         }
19436         return NDR_ERR_SUCCESS;
19437 }
19438
19439 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19440 {
19441         if (ndr_flags & NDR_SCALARS) {
19442                 NDR_CHECK(ndr_pull_align(ndr, 4));
19443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19444                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19445         }
19446         if (ndr_flags & NDR_BUFFERS) {
19447         }
19448         return NDR_ERR_SUCCESS;
19449 }
19450
19451 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19452 {
19453         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19454         ndr->depth++;
19455         ndr_print_uint32(ndr, "not_used", r->not_used);
19456         ndr->depth--;
19457 }
19458
19459 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19460 {
19461         if (ndr_flags & NDR_SCALARS) {
19462                 NDR_CHECK(ndr_push_align(ndr, 5));
19463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19467                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19469                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19470                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19471                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19472                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19473                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19474         }
19475         if (ndr_flags & NDR_BUFFERS) {
19476                 if (r->client) {
19477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19478                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19480                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19481                 }
19482                 if (r->user) {
19483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19486                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19487                 }
19488         }
19489         return NDR_ERR_SUCCESS;
19490 }
19491
19492 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19493 {
19494         uint32_t _ptr_client;
19495         TALLOC_CTX *_mem_save_client_0;
19496         uint32_t _ptr_user;
19497         TALLOC_CTX *_mem_save_user_0;
19498         if (ndr_flags & NDR_SCALARS) {
19499                 NDR_CHECK(ndr_pull_align(ndr, 5));
19500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19504                 if (_ptr_client) {
19505                         NDR_PULL_ALLOC(ndr, r->client);
19506                 } else {
19507                         r->client = NULL;
19508                 }
19509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19510                 if (_ptr_user) {
19511                         NDR_PULL_ALLOC(ndr, r->user);
19512                 } else {
19513                         r->user = NULL;
19514                 }
19515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19516                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19517                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19518                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19519                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19520                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19521         }
19522         if (ndr_flags & NDR_BUFFERS) {
19523                 if (r->client) {
19524                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19525                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19528                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19529                                 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));
19530                         }
19531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19532                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19534                 }
19535                 if (r->user) {
19536                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19537                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19540                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19541                                 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));
19542                         }
19543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19546                 }
19547         }
19548         return NDR_ERR_SUCCESS;
19549 }
19550
19551 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19552 {
19553         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19554         ndr->depth++;
19555         ndr_print_uint32(ndr, "size", r->size);
19556         ndr_print_uint32(ndr, "flags", r->flags);
19557         ndr_print_uint32(ndr, "size2", r->size2);
19558         ndr_print_ptr(ndr, "client", r->client);
19559         ndr->depth++;
19560         if (r->client) {
19561                 ndr_print_string(ndr, "client", r->client);
19562         }
19563         ndr->depth--;
19564         ndr_print_ptr(ndr, "user", r->user);
19565         ndr->depth++;
19566         if (r->user) {
19567                 ndr_print_string(ndr, "user", r->user);
19568         }
19569         ndr->depth--;
19570         ndr_print_uint32(ndr, "build", r->build);
19571         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19572         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19573         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19574         ndr_print_udlong(ndr, "reserved", r->reserved);
19575         ndr->depth--;
19576 }
19577
19578 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19579 {
19580         if (ndr_flags & NDR_SCALARS) {
19581                 int level = ndr_push_get_switch_value(ndr, r);
19582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19583                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19584                 switch (level) {
19585                         case 1: {
19586                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19587                         break; }
19588
19589                         case 2: {
19590                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19591                         break; }
19592
19593                         case 3: {
19594                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19595                         break; }
19596
19597                         default:
19598                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19599                 }
19600         }
19601         if (ndr_flags & NDR_BUFFERS) {
19602                 int level = ndr_push_get_switch_value(ndr, r);
19603                 switch (level) {
19604                         case 1:
19605                                 if (r->level1) {
19606                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19607                                 }
19608                         break;
19609
19610                         case 2:
19611                                 if (r->level2) {
19612                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19613                                 }
19614                         break;
19615
19616                         case 3:
19617                                 if (r->level3) {
19618                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19619                                 }
19620                         break;
19621
19622                         default:
19623                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19624                 }
19625         }
19626         return NDR_ERR_SUCCESS;
19627 }
19628
19629 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19630 {
19631         int level;
19632         uint32_t _level;
19633         TALLOC_CTX *_mem_save_level1_0;
19634         TALLOC_CTX *_mem_save_level2_0;
19635         TALLOC_CTX *_mem_save_level3_0;
19636         level = ndr_pull_get_switch_value(ndr, r);
19637         if (ndr_flags & NDR_SCALARS) {
19638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19639                 if (_level != level) {
19640                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19641                 }
19642                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19643                 switch (level) {
19644                         case 1: {
19645                                 uint32_t _ptr_level1;
19646                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19647                                 if (_ptr_level1) {
19648                                         NDR_PULL_ALLOC(ndr, r->level1);
19649                                 } else {
19650                                         r->level1 = NULL;
19651                                 }
19652                         break; }
19653
19654                         case 2: {
19655                                 uint32_t _ptr_level2;
19656                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19657                                 if (_ptr_level2) {
19658                                         NDR_PULL_ALLOC(ndr, r->level2);
19659                                 } else {
19660                                         r->level2 = NULL;
19661                                 }
19662                         break; }
19663
19664                         case 3: {
19665                                 uint32_t _ptr_level3;
19666                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19667                                 if (_ptr_level3) {
19668                                         NDR_PULL_ALLOC(ndr, r->level3);
19669                                 } else {
19670                                         r->level3 = NULL;
19671                                 }
19672                         break; }
19673
19674                         default:
19675                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19676                 }
19677         }
19678         if (ndr_flags & NDR_BUFFERS) {
19679                 switch (level) {
19680                         case 1:
19681                                 if (r->level1) {
19682                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19683                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19684                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19685                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19686                                 }
19687                         break;
19688
19689                         case 2:
19690                                 if (r->level2) {
19691                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19692                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19693                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19694                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19695                                 }
19696                         break;
19697
19698                         case 3:
19699                                 if (r->level3) {
19700                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19701                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19702                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19703                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19704                                 }
19705                         break;
19706
19707                         default:
19708                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19709                 }
19710         }
19711         return NDR_ERR_SUCCESS;
19712 }
19713
19714 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19715 {
19716         int level;
19717         level = ndr_print_get_switch_value(ndr, r);
19718         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19719         switch (level) {
19720                 case 1:
19721                         ndr_print_ptr(ndr, "level1", r->level1);
19722                         ndr->depth++;
19723                         if (r->level1) {
19724                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19725                         }
19726                         ndr->depth--;
19727                 break;
19728
19729                 case 2:
19730                         ndr_print_ptr(ndr, "level2", r->level2);
19731                         ndr->depth++;
19732                         if (r->level2) {
19733                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19734                         }
19735                         ndr->depth--;
19736                 break;
19737
19738                 case 3:
19739                         ndr_print_ptr(ndr, "level3", r->level3);
19740                         ndr->depth++;
19741                         if (r->level3) {
19742                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19743                         }
19744                         ndr->depth--;
19745                 break;
19746
19747                 default:
19748                         ndr_print_bad_level(ndr, name, level);
19749         }
19750 }
19751
19752 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19753 {
19754         if (ndr_flags & NDR_SCALARS) {
19755                 NDR_CHECK(ndr_push_align(ndr, 5));
19756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19757                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19758                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19759                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19760         }
19761         if (ndr_flags & NDR_BUFFERS) {
19762                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19763         }
19764         return NDR_ERR_SUCCESS;
19765 }
19766
19767 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19768 {
19769         if (ndr_flags & NDR_SCALARS) {
19770                 NDR_CHECK(ndr_pull_align(ndr, 5));
19771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19772                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19773                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19774                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19775         }
19776         if (ndr_flags & NDR_BUFFERS) {
19777                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19778         }
19779         return NDR_ERR_SUCCESS;
19780 }
19781
19782 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19783 {
19784         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19785         ndr->depth++;
19786         ndr_print_uint32(ndr, "level", r->level);
19787         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19788         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19789         ndr->depth--;
19790 }
19791
19792 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19793 {
19794         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19795         return NDR_ERR_SUCCESS;
19796 }
19797
19798 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19799 {
19800         uint32_t v;
19801         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19802         *r = v;
19803         return NDR_ERR_SUCCESS;
19804 }
19805
19806 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19807 {
19808         ndr_print_uint32(ndr, name, r);
19809         ndr->depth++;
19810         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19811         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19812         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19813         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19814         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19815         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19816         ndr->depth--;
19817 }
19818
19819 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19820 {
19821         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19822         if (ndr_flags & NDR_SCALARS) {
19823                 NDR_CHECK(ndr_push_align(ndr, 5));
19824                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19825                 {
19826                         uint32_t _flags_save_string = ndr->flags;
19827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19828                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19829                         ndr->flags = _flags_save_string;
19830                 }
19831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19832                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19833                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19835                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19836         }
19837         if (ndr_flags & NDR_BUFFERS) {
19838                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19839                 {
19840                         uint32_t _flags_save_string = ndr->flags;
19841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19842                         if (r->value_name) {
19843                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value_name));
19844                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19845                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value_name));
19846                         }
19847                         ndr->flags = _flags_save_string;
19848                 }
19849                 if (r->data) {
19850                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data));
19851                         {
19852                                 struct ndr_push *_ndr_data;
19853                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19854                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19855                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19856                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19857                         }
19858                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data));
19859                 }
19860         }
19861         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19862         return NDR_ERR_SUCCESS;
19863 }
19864
19865 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19866 {
19867         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19868         uint32_t _ptr_value_name;
19869         TALLOC_CTX *_mem_save_value_name_0;
19870         uint32_t _ptr_data;
19871         TALLOC_CTX *_mem_save_data_0;
19872         if (ndr_flags & NDR_SCALARS) {
19873                 NDR_CHECK(ndr_pull_align(ndr, 5));
19874                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19875                 {
19876                         uint32_t _flags_save_string = ndr->flags;
19877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19878                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19879                         if (_ptr_value_name) {
19880                                 NDR_PULL_ALLOC(ndr, r->value_name);
19881                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19882                         } else {
19883                                 r->value_name = NULL;
19884                         }
19885                         ndr->flags = _flags_save_string;
19886                 }
19887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19888                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19890                 if (_ptr_data) {
19891                         NDR_PULL_ALLOC(ndr, r->data);
19892                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19893                 } else {
19894                         r->data = NULL;
19895                 }
19896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19897                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19898         }
19899         if (ndr_flags & NDR_BUFFERS) {
19900                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19901                 {
19902                         uint32_t _flags_save_string = ndr->flags;
19903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19904                         if (r->value_name) {
19905                                 uint32_t _relative_save_offset;
19906                                 _relative_save_offset = ndr->offset;
19907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19908                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19909                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19910                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19912                                 if (ndr->offset > ndr->relative_highest_offset) {
19913                                         ndr->relative_highest_offset = ndr->offset;
19914                                 }
19915                                 ndr->offset = _relative_save_offset;
19916                         }
19917                         ndr->flags = _flags_save_string;
19918                 }
19919                 if (r->data) {
19920                         uint32_t _relative_save_offset;
19921                         _relative_save_offset = ndr->offset;
19922                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19923                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19924                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19925                         {
19926                                 struct ndr_pull *_ndr_data;
19927                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19928                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19929                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19930                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19931                         }
19932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19933                         if (ndr->offset > ndr->relative_highest_offset) {
19934                                 ndr->relative_highest_offset = ndr->offset;
19935                         }
19936                         ndr->offset = _relative_save_offset;
19937                 }
19938         }
19939         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19940         return NDR_ERR_SUCCESS;
19941 }
19942
19943 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19944 {
19945         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19946         ndr->depth++;
19947         ndr_print_ptr(ndr, "value_name", r->value_name);
19948         ndr->depth++;
19949         if (r->value_name) {
19950                 ndr_print_string(ndr, "value_name", r->value_name);
19951         }
19952         ndr->depth--;
19953         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19954         ndr_print_winreg_Type(ndr, "type", r->type);
19955         ndr_print_ptr(ndr, "data", r->data);
19956         ndr->depth++;
19957         if (r->data) {
19958                 ndr_print_set_switch_value(ndr, r->data, r->type);
19959                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19960         }
19961         ndr->depth--;
19962         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);
19963         ndr->depth--;
19964 }
19965
19966 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19967 {
19968         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19969 }
19970
19971 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
19972 {
19973         if (ndr_flags & NDR_SCALARS) {
19974                 int level = ndr_push_get_switch_value(ndr, r);
19975                 NDR_CHECK(ndr_push_union_align(ndr, 4));
19976                 switch (level) {
19977                         case 0: {
19978                         break; }
19979
19980                         case 1: {
19981                         break; }
19982
19983                         default: {
19984                                 {
19985                                         uint32_t _flags_save_string_array = ndr->flags;
19986                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19987                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
19988                                         ndr->flags = _flags_save_string_array;
19989                                 }
19990                         break; }
19991
19992                 }
19993         }
19994         if (ndr_flags & NDR_BUFFERS) {
19995                 int level = ndr_push_get_switch_value(ndr, r);
19996                 switch (level) {
19997                         case 0:
19998                         break;
19999
20000                         case 1:
20001                         break;
20002
20003                         default:
20004                         break;
20005
20006                 }
20007         }
20008         return NDR_ERR_SUCCESS;
20009 }
20010
20011 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
20012 {
20013         int level;
20014         level = ndr_pull_get_switch_value(ndr, r);
20015         if (ndr_flags & NDR_SCALARS) {
20016                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
20017                 switch (level) {
20018                         case 0: {
20019                         break; }
20020
20021                         case 1: {
20022                         break; }
20023
20024                         default: {
20025                                 {
20026                                         uint32_t _flags_save_string_array = ndr->flags;
20027                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20028                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
20029                                         ndr->flags = _flags_save_string_array;
20030                                 }
20031                         break; }
20032
20033                 }
20034         }
20035         if (ndr_flags & NDR_BUFFERS) {
20036                 switch (level) {
20037                         case 0:
20038                         break;
20039
20040                         case 1:
20041                         break;
20042
20043                         default:
20044                         break;
20045
20046                 }
20047         }
20048         return NDR_ERR_SUCCESS;
20049 }
20050
20051 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
20052 {
20053         int level;
20054         level = ndr_print_get_switch_value(ndr, r);
20055         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
20056         switch (level) {
20057                 case 0:
20058                 break;
20059
20060                 case 1:
20061                 break;
20062
20063                 default:
20064                         ndr_print_string_array(ndr, "string_array", r->string_array);
20065                 break;
20066
20067         }
20068 }
20069
20070 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20071 {
20072         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20073         return NDR_ERR_SUCCESS;
20074 }
20075
20076 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20077 {
20078         uint32_t v;
20079         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20080         *r = v;
20081         return NDR_ERR_SUCCESS;
20082 }
20083
20084 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20085 {
20086         ndr_print_uint32(ndr, name, r);
20087         ndr->depth++;
20088         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
20089         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
20090         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
20091         ndr->depth--;
20092 }
20093
20094 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
20095 {
20096         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
20097         return NDR_ERR_SUCCESS;
20098 }
20099
20100 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
20101 {
20102         uint32_t v;
20103         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
20104         *r = v;
20105         return NDR_ERR_SUCCESS;
20106 }
20107
20108 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
20109 {
20110         const char *val = NULL;
20111
20112         switch (r) {
20113                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
20114                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
20115         }
20116         ndr_print_enum(ndr, name, "ENUM", val, r);
20117 }
20118
20119 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
20120 {
20121         if (ndr_flags & NDR_SCALARS) {
20122                 NDR_CHECK(ndr_push_align(ndr, 4));
20123                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
20125                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20128                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20129                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20131                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20132                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20133                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20134                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20138                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20139         }
20140         if (ndr_flags & NDR_BUFFERS) {
20141         }
20142         return NDR_ERR_SUCCESS;
20143 }
20144
20145 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
20146 {
20147         if (ndr_flags & NDR_SCALARS) {
20148                 NDR_CHECK(ndr_pull_align(ndr, 4));
20149                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20151                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20154                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20155                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20157                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20158                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20159                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20160                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20164                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20165         }
20166         if (ndr_flags & NDR_BUFFERS) {
20167         }
20168         return NDR_ERR_SUCCESS;
20169 }
20170
20171 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
20172 {
20173         ndr_print_struct(ndr, name, "spoolss_PortData1");
20174         ndr->depth++;
20175         ndr_print_string(ndr, "portname", r->portname);
20176         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
20177         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20178         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20179         ndr_print_uint32(ndr, "reserved", r->reserved);
20180         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20181         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20182         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20183         ndr_print_string(ndr, "queue", r->queue);
20184         ndr_print_string(ndr, "ip_address", r->ip_address);
20185         ndr_print_string(ndr, "hardware_address", r->hardware_address);
20186         ndr_print_string(ndr, "device_type", r->device_type);
20187         ndr_print_uint32(ndr, "port_number", r->port_number);
20188         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20189         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20190         ndr->depth--;
20191 }
20192
20193 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
20194 {
20195         if (ndr_flags & NDR_SCALARS) {
20196                 NDR_CHECK(ndr_push_align(ndr, 4));
20197                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
20199                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20202                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20203                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20205                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20206                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
20211                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20212         }
20213         if (ndr_flags & NDR_BUFFERS) {
20214         }
20215         return NDR_ERR_SUCCESS;
20216 }
20217
20218 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
20219 {
20220         if (ndr_flags & NDR_SCALARS) {
20221                 NDR_CHECK(ndr_pull_align(ndr, 4));
20222                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20224                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20227                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20228                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20230                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20231                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
20236                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20237         }
20238         if (ndr_flags & NDR_BUFFERS) {
20239         }
20240         return NDR_ERR_SUCCESS;
20241 }
20242
20243 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
20244 {
20245         ndr_print_struct(ndr, name, "spoolss_PortData2");
20246         ndr->depth++;
20247         ndr_print_string(ndr, "portname", r->portname);
20248         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
20249         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20250         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20251         ndr_print_uint32(ndr, "reserved", r->reserved);
20252         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20253         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20254         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20255         ndr_print_string(ndr, "queue", r->queue);
20256         ndr_print_string(ndr, "device_type", r->device_type);
20257         ndr_print_uint32(ndr, "port_number", r->port_number);
20258         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20259         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20260         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
20261         ndr->depth--;
20262 }
20263
20264 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
20265 {
20266         if (ndr_flags & NDR_SCALARS) {
20267                 NDR_CHECK(ndr_push_align(ndr, 4));
20268                 {
20269                         uint32_t _flags_save_string = ndr->flags;
20270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20271                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
20272                         ndr->flags = _flags_save_string;
20273                 }
20274                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20275         }
20276         if (ndr_flags & NDR_BUFFERS) {
20277         }
20278         return NDR_ERR_SUCCESS;
20279 }
20280
20281 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
20282 {
20283         if (ndr_flags & NDR_SCALARS) {
20284                 NDR_CHECK(ndr_pull_align(ndr, 4));
20285                 {
20286                         uint32_t _flags_save_string = ndr->flags;
20287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20288                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
20289                         ndr->flags = _flags_save_string;
20290                 }
20291                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20292         }
20293         if (ndr_flags & NDR_BUFFERS) {
20294         }
20295         return NDR_ERR_SUCCESS;
20296 }
20297
20298 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
20299 {
20300         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
20301         ndr->depth++;
20302         ndr_print_string(ndr, "dll_name", r->dll_name);
20303         ndr->depth--;
20304 }
20305
20306 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20307 {
20308         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20309         return NDR_ERR_SUCCESS;
20310 }
20311
20312 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20313 {
20314         uint32_t v;
20315         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20316         *r = v;
20317         return NDR_ERR_SUCCESS;
20318 }
20319
20320 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20321 {
20322         ndr_print_uint32(ndr, name, r);
20323         ndr->depth++;
20324         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20325         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20326         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20327         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20328         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20329         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20330         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20331         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20332         ndr->depth--;
20333 }
20334
20335 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20336 {
20337         if (ndr_flags & NDR_SCALARS) {
20338                 NDR_CHECK(ndr_push_align(ndr, 8));
20339                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20340                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20341                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20342                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20343                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20344         }
20345         if (ndr_flags & NDR_BUFFERS) {
20346         }
20347         return NDR_ERR_SUCCESS;
20348 }
20349
20350 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20351 {
20352         if (ndr_flags & NDR_SCALARS) {
20353                 NDR_CHECK(ndr_pull_align(ndr, 8));
20354                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20355                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20356                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20357                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
20358                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20359         }
20360         if (ndr_flags & NDR_BUFFERS) {
20361         }
20362         return NDR_ERR_SUCCESS;
20363 }
20364
20365 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20366 {
20367         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20368         ndr->depth++;
20369         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20370         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20371         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20372         ndr_print_string(ndr, "formname", r->formname);
20373         ndr->depth--;
20374 }
20375
20376 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20377 {
20378         if (flags & NDR_IN) {
20379                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20381                 if (r->in.server) {
20382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20383                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20384                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20385                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20386                 }
20387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20389                 if (r->in.buffer) {
20390                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20391                 }
20392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20393         }
20394         if (flags & NDR_OUT) {
20395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20396                 if (r->out.info) {
20397                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20398                 }
20399                 if (r->out.needed == NULL) {
20400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20401                 }
20402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20403                 if (r->out.count == NULL) {
20404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20405                 }
20406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20408         }
20409         return NDR_ERR_SUCCESS;
20410 }
20411
20412 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20413 {
20414         uint32_t _ptr_server;
20415         uint32_t _ptr_buffer;
20416         uint32_t _ptr_info;
20417         TALLOC_CTX *_mem_save_server_0;
20418         TALLOC_CTX *_mem_save_buffer_0;
20419         TALLOC_CTX *_mem_save_info_0;
20420         TALLOC_CTX *_mem_save_needed_0;
20421         TALLOC_CTX *_mem_save_count_0;
20422         if (flags & NDR_IN) {
20423                 ZERO_STRUCT(r->out);
20424
20425                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20427                 if (_ptr_server) {
20428                         NDR_PULL_ALLOC(ndr, r->in.server);
20429                 } else {
20430                         r->in.server = NULL;
20431                 }
20432                 if (r->in.server) {
20433                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20434                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20437                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20438                                 return 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));
20439                         }
20440                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20441                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20443                 }
20444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20446                 if (_ptr_buffer) {
20447                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20448                 } else {
20449                         r->in.buffer = NULL;
20450                 }
20451                 if (r->in.buffer) {
20452                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20453                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20454                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20455                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20456                 }
20457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20458                 NDR_PULL_ALLOC(ndr, r->out.needed);
20459                 ZERO_STRUCTP(r->out.needed);
20460                 NDR_PULL_ALLOC(ndr, r->out.count);
20461                 ZERO_STRUCTP(r->out.count);
20462         }
20463         if (flags & NDR_OUT) {
20464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20465                 if (_ptr_info) {
20466                         NDR_PULL_ALLOC(ndr, r->out.info);
20467                 } else {
20468                         r->out.info = NULL;
20469                 }
20470                 if (r->out.info) {
20471                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20472                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20473                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20475                 }
20476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20477                         NDR_PULL_ALLOC(ndr, r->out.needed);
20478                 }
20479                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20480                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20484                         NDR_PULL_ALLOC(ndr, r->out.count);
20485                 }
20486                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20487                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20491         }
20492         return NDR_ERR_SUCCESS;
20493 }
20494
20495 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20496 {
20497         uint32_t cntr_info_0;
20498         if (flags & NDR_IN) {
20499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20501         }
20502         if (flags & NDR_OUT) {
20503                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20504                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20505                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20506                 }
20507                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20508                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20509                 }
20510         }
20511         return NDR_ERR_SUCCESS;
20512 }
20513
20514 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20515 {
20516         uint32_t cntr_info_0;
20517         TALLOC_CTX *_mem_save_info_0;
20518         if (flags & NDR_IN) {
20519                 ZERO_STRUCT(r->out);
20520
20521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20523         }
20524         if (flags & NDR_OUT) {
20525                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20526                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20527                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20528                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20529                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20530                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20531                 }
20532                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20533                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20534                 }
20535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20536         }
20537         return NDR_ERR_SUCCESS;
20538 }
20539
20540 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20541 {
20542         uint32_t cntr_info_2;
20543         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20544         ndr->depth++;
20545         if (flags & NDR_SET_VALUES) {
20546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20547         }
20548         if (flags & NDR_IN) {
20549                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20550                 ndr->depth++;
20551                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20552                 ndr_print_ptr(ndr, "server", r->in.server);
20553                 ndr->depth++;
20554                 if (r->in.server) {
20555                         ndr_print_string(ndr, "server", r->in.server);
20556                 }
20557                 ndr->depth--;
20558                 ndr_print_uint32(ndr, "level", r->in.level);
20559                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20560                 ndr->depth++;
20561                 if (r->in.buffer) {
20562                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20563                 }
20564                 ndr->depth--;
20565                 ndr_print_uint32(ndr, "offered", r->in.offered);
20566                 ndr->depth--;
20567         }
20568         if (flags & NDR_OUT) {
20569                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20570                 ndr->depth++;
20571                 ndr_print_ptr(ndr, "count", r->out.count);
20572                 ndr->depth++;
20573                 ndr_print_uint32(ndr, "count", *r->out.count);
20574                 ndr->depth--;
20575                 ndr_print_ptr(ndr, "info", r->out.info);
20576                 ndr->depth++;
20577                 ndr_print_ptr(ndr, "info", *r->out.info);
20578                 ndr->depth++;
20579                 if (*r->out.info) {
20580                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20581                         ndr->depth++;
20582                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20583                                 char *idx_2=NULL;
20584                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20585                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20586                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20587                                         free(idx_2);
20588                                 }
20589                         }
20590                         ndr->depth--;
20591                 }
20592                 ndr->depth--;
20593                 ndr->depth--;
20594                 ndr_print_ptr(ndr, "needed", r->out.needed);
20595                 ndr->depth++;
20596                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20597                 ndr->depth--;
20598                 ndr_print_WERROR(ndr, "result", r->out.result);
20599                 ndr->depth--;
20600         }
20601         ndr->depth--;
20602 }
20603
20604 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20605 {
20606         if (flags & NDR_IN) {
20607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20608                 if (r->in.printername) {
20609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20612                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20613                 }
20614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20615                 if (r->in.datatype) {
20616                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20618                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20620                 }
20621                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20622                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20623         }
20624         if (flags & NDR_OUT) {
20625                 if (r->out.handle == NULL) {
20626                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20627                 }
20628                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20629                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20630         }
20631         return NDR_ERR_SUCCESS;
20632 }
20633
20634 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20635 {
20636         uint32_t _ptr_printername;
20637         uint32_t _ptr_datatype;
20638         TALLOC_CTX *_mem_save_printername_0;
20639         TALLOC_CTX *_mem_save_datatype_0;
20640         TALLOC_CTX *_mem_save_handle_0;
20641         if (flags & NDR_IN) {
20642                 ZERO_STRUCT(r->out);
20643
20644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20645                 if (_ptr_printername) {
20646                         NDR_PULL_ALLOC(ndr, r->in.printername);
20647                 } else {
20648                         r->in.printername = NULL;
20649                 }
20650                 if (r->in.printername) {
20651                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20652                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20655                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20656                                 return 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));
20657                         }
20658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20659                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20661                 }
20662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20663                 if (_ptr_datatype) {
20664                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20665                 } else {
20666                         r->in.datatype = NULL;
20667                 }
20668                 if (r->in.datatype) {
20669                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20670                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20673                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20674                                 return 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));
20675                         }
20676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20679                 }
20680                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20681                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20682                 NDR_PULL_ALLOC(ndr, r->out.handle);
20683                 ZERO_STRUCTP(r->out.handle);
20684         }
20685         if (flags & NDR_OUT) {
20686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20687                         NDR_PULL_ALLOC(ndr, r->out.handle);
20688                 }
20689                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20690                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20691                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20692                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20693                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20694         }
20695         return NDR_ERR_SUCCESS;
20696 }
20697
20698 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20699 {
20700         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20701         ndr->depth++;
20702         if (flags & NDR_SET_VALUES) {
20703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20704         }
20705         if (flags & NDR_IN) {
20706                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20707                 ndr->depth++;
20708                 ndr_print_ptr(ndr, "printername", r->in.printername);
20709                 ndr->depth++;
20710                 if (r->in.printername) {
20711                         ndr_print_string(ndr, "printername", r->in.printername);
20712                 }
20713                 ndr->depth--;
20714                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20715                 ndr->depth++;
20716                 if (r->in.datatype) {
20717                         ndr_print_string(ndr, "datatype", r->in.datatype);
20718                 }
20719                 ndr->depth--;
20720                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20721                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20722                 ndr->depth--;
20723         }
20724         if (flags & NDR_OUT) {
20725                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20726                 ndr->depth++;
20727                 ndr_print_ptr(ndr, "handle", r->out.handle);
20728                 ndr->depth++;
20729                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20730                 ndr->depth--;
20731                 ndr_print_WERROR(ndr, "result", r->out.result);
20732                 ndr->depth--;
20733         }
20734         ndr->depth--;
20735 }
20736
20737 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20738 {
20739         if (flags & NDR_IN) {
20740                 if (r->in.handle == NULL) {
20741                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20742                 }
20743                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20746                 if (r->in.ctr) {
20747                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20748                 }
20749                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20750         }
20751         if (flags & NDR_OUT) {
20752                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20753         }
20754         return NDR_ERR_SUCCESS;
20755 }
20756
20757 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20758 {
20759         uint32_t _ptr_ctr;
20760         TALLOC_CTX *_mem_save_handle_0;
20761         TALLOC_CTX *_mem_save_ctr_0;
20762         if (flags & NDR_IN) {
20763                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20764                         NDR_PULL_ALLOC(ndr, r->in.handle);
20765                 }
20766                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20767                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20768                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20769                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20772                 if (_ptr_ctr) {
20773                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20774                 } else {
20775                         r->in.ctr = NULL;
20776                 }
20777                 if (r->in.ctr) {
20778                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20779                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20780                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20782                 }
20783                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20784         }
20785         if (flags & NDR_OUT) {
20786                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20787         }
20788         return NDR_ERR_SUCCESS;
20789 }
20790
20791 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20792 {
20793         ndr_print_struct(ndr, name, "spoolss_SetJob");
20794         ndr->depth++;
20795         if (flags & NDR_SET_VALUES) {
20796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20797         }
20798         if (flags & NDR_IN) {
20799                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20800                 ndr->depth++;
20801                 ndr_print_ptr(ndr, "handle", r->in.handle);
20802                 ndr->depth++;
20803                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20804                 ndr->depth--;
20805                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20806                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20807                 ndr->depth++;
20808                 if (r->in.ctr) {
20809                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20810                 }
20811                 ndr->depth--;
20812                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20813                 ndr->depth--;
20814         }
20815         if (flags & NDR_OUT) {
20816                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20817                 ndr->depth++;
20818                 ndr_print_WERROR(ndr, "result", r->out.result);
20819                 ndr->depth--;
20820         }
20821         ndr->depth--;
20822 }
20823
20824 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20825 {
20826         if (flags & NDR_IN) {
20827                 if (r->in.handle == NULL) {
20828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20829                 }
20830                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20834                 if (r->in.buffer) {
20835                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20836                 }
20837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20838         }
20839         if (flags & NDR_OUT) {
20840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20841                 if (r->out.info) {
20842                         {
20843                                 struct ndr_push *_ndr_info;
20844                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20845                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20846                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20847                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20848                         }
20849                 }
20850                 if (r->out.needed == NULL) {
20851                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20852                 }
20853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20854                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20855         }
20856         return NDR_ERR_SUCCESS;
20857 }
20858
20859 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20860 {
20861         uint32_t _ptr_buffer;
20862         uint32_t _ptr_info;
20863         TALLOC_CTX *_mem_save_handle_0;
20864         TALLOC_CTX *_mem_save_buffer_0;
20865         TALLOC_CTX *_mem_save_info_0;
20866         TALLOC_CTX *_mem_save_needed_0;
20867         if (flags & NDR_IN) {
20868                 ZERO_STRUCT(r->out);
20869
20870                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20871                         NDR_PULL_ALLOC(ndr, r->in.handle);
20872                 }
20873                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20874                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20875                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20876                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20880                 if (_ptr_buffer) {
20881                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20882                 } else {
20883                         r->in.buffer = NULL;
20884                 }
20885                 if (r->in.buffer) {
20886                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20887                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20888                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20890                 }
20891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20892                 NDR_PULL_ALLOC(ndr, r->out.needed);
20893                 ZERO_STRUCTP(r->out.needed);
20894         }
20895         if (flags & NDR_OUT) {
20896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20897                 if (_ptr_info) {
20898                         NDR_PULL_ALLOC(ndr, r->out.info);
20899                 } else {
20900                         r->out.info = NULL;
20901                 }
20902                 if (r->out.info) {
20903                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20904                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20905                         {
20906                                 struct ndr_pull *_ndr_info;
20907                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20908                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20909                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20910                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20911                         }
20912                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20913                 }
20914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20915                         NDR_PULL_ALLOC(ndr, r->out.needed);
20916                 }
20917                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20918                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20921                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20922         }
20923         return NDR_ERR_SUCCESS;
20924 }
20925
20926 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20927 {
20928         ndr_print_struct(ndr, name, "spoolss_GetJob");
20929         ndr->depth++;
20930         if (flags & NDR_SET_VALUES) {
20931                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20932         }
20933         if (flags & NDR_IN) {
20934                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
20935                 ndr->depth++;
20936                 ndr_print_ptr(ndr, "handle", r->in.handle);
20937                 ndr->depth++;
20938                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20939                 ndr->depth--;
20940                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20941                 ndr_print_uint32(ndr, "level", r->in.level);
20942                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20943                 ndr->depth++;
20944                 if (r->in.buffer) {
20945                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20946                 }
20947                 ndr->depth--;
20948                 ndr_print_uint32(ndr, "offered", r->in.offered);
20949                 ndr->depth--;
20950         }
20951         if (flags & NDR_OUT) {
20952                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
20953                 ndr->depth++;
20954                 ndr_print_ptr(ndr, "info", r->out.info);
20955                 ndr->depth++;
20956                 if (r->out.info) {
20957                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20958                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20959                 }
20960                 ndr->depth--;
20961                 ndr_print_ptr(ndr, "needed", r->out.needed);
20962                 ndr->depth++;
20963                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20964                 ndr->depth--;
20965                 ndr_print_WERROR(ndr, "result", r->out.result);
20966                 ndr->depth--;
20967         }
20968         ndr->depth--;
20969 }
20970
20971 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20972 {
20973         if (flags & NDR_IN) {
20974                 if (r->in.handle == NULL) {
20975                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20976                 }
20977                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20981                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20982                 if (r->in.buffer) {
20983                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20984                 }
20985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20986         }
20987         if (flags & NDR_OUT) {
20988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20989                 if (r->out.info) {
20990                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20991                 }
20992                 if (r->out.needed == NULL) {
20993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20994                 }
20995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20996                 if (r->out.count == NULL) {
20997                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20998                 }
20999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21000                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21001         }
21002         return NDR_ERR_SUCCESS;
21003 }
21004
21005 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
21006 {
21007         uint32_t _ptr_buffer;
21008         uint32_t _ptr_info;
21009         TALLOC_CTX *_mem_save_handle_0;
21010         TALLOC_CTX *_mem_save_buffer_0;
21011         TALLOC_CTX *_mem_save_info_0;
21012         TALLOC_CTX *_mem_save_needed_0;
21013         TALLOC_CTX *_mem_save_count_0;
21014         if (flags & NDR_IN) {
21015                 ZERO_STRUCT(r->out);
21016
21017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21018                         NDR_PULL_ALLOC(ndr, r->in.handle);
21019                 }
21020                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21021                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21022                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
21025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
21026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21028                 if (_ptr_buffer) {
21029                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21030                 } else {
21031                         r->in.buffer = NULL;
21032                 }
21033                 if (r->in.buffer) {
21034                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21035                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21036                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21038                 }
21039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21040                 NDR_PULL_ALLOC(ndr, r->out.needed);
21041                 ZERO_STRUCTP(r->out.needed);
21042                 NDR_PULL_ALLOC(ndr, r->out.count);
21043                 ZERO_STRUCTP(r->out.count);
21044         }
21045         if (flags & NDR_OUT) {
21046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21047                 if (_ptr_info) {
21048                         NDR_PULL_ALLOC(ndr, r->out.info);
21049                 } else {
21050                         r->out.info = NULL;
21051                 }
21052                 if (r->out.info) {
21053                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21054                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21055                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21057                 }
21058                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21059                         NDR_PULL_ALLOC(ndr, r->out.needed);
21060                 }
21061                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21062                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21064                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21066                         NDR_PULL_ALLOC(ndr, r->out.count);
21067                 }
21068                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21069                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21073         }
21074         return NDR_ERR_SUCCESS;
21075 }
21076
21077 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
21078 {
21079         uint32_t cntr_info_0;
21080         if (flags & NDR_IN) {
21081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21083         }
21084         if (flags & NDR_OUT) {
21085                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21086                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21087                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21088                 }
21089                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21090                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21091                 }
21092         }
21093         return NDR_ERR_SUCCESS;
21094 }
21095
21096 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
21097 {
21098         uint32_t cntr_info_0;
21099         TALLOC_CTX *_mem_save_info_0;
21100         if (flags & NDR_IN) {
21101                 ZERO_STRUCT(r->out);
21102
21103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21105         }
21106         if (flags & NDR_OUT) {
21107                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21108                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21109                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21110                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21111                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21112                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21113                 }
21114                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21115                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21116                 }
21117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21118         }
21119         return NDR_ERR_SUCCESS;
21120 }
21121
21122 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
21123 {
21124         uint32_t cntr_info_2;
21125         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
21126         ndr->depth++;
21127         if (flags & NDR_SET_VALUES) {
21128                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21129         }
21130         if (flags & NDR_IN) {
21131                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
21132                 ndr->depth++;
21133                 ndr_print_ptr(ndr, "handle", r->in.handle);
21134                 ndr->depth++;
21135                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21136                 ndr->depth--;
21137                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
21138                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
21139                 ndr_print_uint32(ndr, "level", r->in.level);
21140                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21141                 ndr->depth++;
21142                 if (r->in.buffer) {
21143                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21144                 }
21145                 ndr->depth--;
21146                 ndr_print_uint32(ndr, "offered", r->in.offered);
21147                 ndr->depth--;
21148         }
21149         if (flags & NDR_OUT) {
21150                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
21151                 ndr->depth++;
21152                 ndr_print_ptr(ndr, "count", r->out.count);
21153                 ndr->depth++;
21154                 ndr_print_uint32(ndr, "count", *r->out.count);
21155                 ndr->depth--;
21156                 ndr_print_ptr(ndr, "info", r->out.info);
21157                 ndr->depth++;
21158                 ndr_print_ptr(ndr, "info", *r->out.info);
21159                 ndr->depth++;
21160                 if (*r->out.info) {
21161                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21162                         ndr->depth++;
21163                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21164                                 char *idx_2=NULL;
21165                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21166                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21167                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21168                                         free(idx_2);
21169                                 }
21170                         }
21171                         ndr->depth--;
21172                 }
21173                 ndr->depth--;
21174                 ndr->depth--;
21175                 ndr_print_ptr(ndr, "needed", r->out.needed);
21176                 ndr->depth++;
21177                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21178                 ndr->depth--;
21179                 ndr_print_WERROR(ndr, "result", r->out.result);
21180                 ndr->depth--;
21181         }
21182         ndr->depth--;
21183 }
21184
21185 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
21186 {
21187         if (flags & NDR_IN) {
21188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21189                 if (r->in.server) {
21190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21193                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21194                 }
21195                 if (r->in.info_ctr == NULL) {
21196                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21197                 }
21198                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21199                 if (r->in.devmode_ctr == NULL) {
21200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21201                 }
21202                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21203                 if (r->in.secdesc_ctr == NULL) {
21204                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21205                 }
21206                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21207         }
21208         if (flags & NDR_OUT) {
21209                 if (r->out.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->out.handle));
21213                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21214         }
21215         return NDR_ERR_SUCCESS;
21216 }
21217
21218 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
21219 {
21220         uint32_t _ptr_server;
21221         TALLOC_CTX *_mem_save_server_0;
21222         TALLOC_CTX *_mem_save_info_ctr_0;
21223         TALLOC_CTX *_mem_save_devmode_ctr_0;
21224         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21225         TALLOC_CTX *_mem_save_handle_0;
21226         if (flags & NDR_IN) {
21227                 ZERO_STRUCT(r->out);
21228
21229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21230                 if (_ptr_server) {
21231                         NDR_PULL_ALLOC(ndr, r->in.server);
21232                 } else {
21233                         r->in.server = NULL;
21234                 }
21235                 if (r->in.server) {
21236                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21240                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21241                                 return 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));
21242                         }
21243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21246                 }
21247                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21248                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21249                 }
21250                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21251                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21252                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21253                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21254                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21255                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21256                 }
21257                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21258                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21259                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21260                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21262                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21263                 }
21264                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21265                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21266                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21268                 NDR_PULL_ALLOC(ndr, r->out.handle);
21269                 ZERO_STRUCTP(r->out.handle);
21270         }
21271         if (flags & NDR_OUT) {
21272                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21273                         NDR_PULL_ALLOC(ndr, r->out.handle);
21274                 }
21275                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21276                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21277                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21278                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21279                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21280         }
21281         return NDR_ERR_SUCCESS;
21282 }
21283
21284 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
21285 {
21286         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
21287         ndr->depth++;
21288         if (flags & NDR_SET_VALUES) {
21289                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21290         }
21291         if (flags & NDR_IN) {
21292                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
21293                 ndr->depth++;
21294                 ndr_print_ptr(ndr, "server", r->in.server);
21295                 ndr->depth++;
21296                 if (r->in.server) {
21297                         ndr_print_string(ndr, "server", r->in.server);
21298                 }
21299                 ndr->depth--;
21300                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21301                 ndr->depth++;
21302                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21303                 ndr->depth--;
21304                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21305                 ndr->depth++;
21306                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21307                 ndr->depth--;
21308                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21309                 ndr->depth++;
21310                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21311                 ndr->depth--;
21312                 ndr->depth--;
21313         }
21314         if (flags & NDR_OUT) {
21315                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21316                 ndr->depth++;
21317                 ndr_print_ptr(ndr, "handle", r->out.handle);
21318                 ndr->depth++;
21319                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21320                 ndr->depth--;
21321                 ndr_print_WERROR(ndr, "result", r->out.result);
21322                 ndr->depth--;
21323         }
21324         ndr->depth--;
21325 }
21326
21327 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21328 {
21329         if (flags & NDR_IN) {
21330                 if (r->in.handle == NULL) {
21331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21332                 }
21333                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21334         }
21335         if (flags & NDR_OUT) {
21336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21337         }
21338         return NDR_ERR_SUCCESS;
21339 }
21340
21341 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21342 {
21343         TALLOC_CTX *_mem_save_handle_0;
21344         if (flags & NDR_IN) {
21345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21346                         NDR_PULL_ALLOC(ndr, r->in.handle);
21347                 }
21348                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21349                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21350                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21352         }
21353         if (flags & NDR_OUT) {
21354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21355         }
21356         return NDR_ERR_SUCCESS;
21357 }
21358
21359 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21360 {
21361         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21362         ndr->depth++;
21363         if (flags & NDR_SET_VALUES) {
21364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21365         }
21366         if (flags & NDR_IN) {
21367                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21368                 ndr->depth++;
21369                 ndr_print_ptr(ndr, "handle", r->in.handle);
21370                 ndr->depth++;
21371                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21372                 ndr->depth--;
21373                 ndr->depth--;
21374         }
21375         if (flags & NDR_OUT) {
21376                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21377                 ndr->depth++;
21378                 ndr_print_WERROR(ndr, "result", r->out.result);
21379                 ndr->depth--;
21380         }
21381         ndr->depth--;
21382 }
21383
21384 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21385 {
21386         if (flags & NDR_IN) {
21387                 if (r->in.handle == NULL) {
21388                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21389                 }
21390                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21391                 if (r->in.info_ctr == NULL) {
21392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21393                 }
21394                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21395                 if (r->in.devmode_ctr == NULL) {
21396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21397                 }
21398                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21399                 if (r->in.secdesc_ctr == NULL) {
21400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21401                 }
21402                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21403                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21404         }
21405         if (flags & NDR_OUT) {
21406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21407         }
21408         return NDR_ERR_SUCCESS;
21409 }
21410
21411 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21412 {
21413         TALLOC_CTX *_mem_save_handle_0;
21414         TALLOC_CTX *_mem_save_info_ctr_0;
21415         TALLOC_CTX *_mem_save_devmode_ctr_0;
21416         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21417         if (flags & NDR_IN) {
21418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21419                         NDR_PULL_ALLOC(ndr, r->in.handle);
21420                 }
21421                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21422                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21423                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21426                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21427                 }
21428                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21429                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21430                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21432                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21433                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21434                 }
21435                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21436                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21437                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21439                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21440                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21441                 }
21442                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21443                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21444                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21445                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21446                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21447         }
21448         if (flags & NDR_OUT) {
21449                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21450         }
21451         return NDR_ERR_SUCCESS;
21452 }
21453
21454 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21455 {
21456         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21457         ndr->depth++;
21458         if (flags & NDR_SET_VALUES) {
21459                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21460         }
21461         if (flags & NDR_IN) {
21462                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21463                 ndr->depth++;
21464                 ndr_print_ptr(ndr, "handle", r->in.handle);
21465                 ndr->depth++;
21466                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21467                 ndr->depth--;
21468                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21469                 ndr->depth++;
21470                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21471                 ndr->depth--;
21472                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21473                 ndr->depth++;
21474                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21475                 ndr->depth--;
21476                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21477                 ndr->depth++;
21478                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21479                 ndr->depth--;
21480                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21481                 ndr->depth--;
21482         }
21483         if (flags & NDR_OUT) {
21484                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21485                 ndr->depth++;
21486                 ndr_print_WERROR(ndr, "result", r->out.result);
21487                 ndr->depth--;
21488         }
21489         ndr->depth--;
21490 }
21491
21492 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21493 {
21494         if (flags & NDR_IN) {
21495                 if (r->in.handle == NULL) {
21496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21497                 }
21498                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21500                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21501                 if (r->in.buffer) {
21502                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21503                 }
21504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21505         }
21506         if (flags & NDR_OUT) {
21507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21508                 if (r->out.info) {
21509                         {
21510                                 struct ndr_push *_ndr_info;
21511                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21512                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21513                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21514                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21515                         }
21516                 }
21517                 if (r->out.needed == NULL) {
21518                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21519                 }
21520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21521                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21522         }
21523         return NDR_ERR_SUCCESS;
21524 }
21525
21526 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21527 {
21528         uint32_t _ptr_buffer;
21529         uint32_t _ptr_info;
21530         TALLOC_CTX *_mem_save_handle_0;
21531         TALLOC_CTX *_mem_save_buffer_0;
21532         TALLOC_CTX *_mem_save_info_0;
21533         TALLOC_CTX *_mem_save_needed_0;
21534         if (flags & NDR_IN) {
21535                 ZERO_STRUCT(r->out);
21536
21537                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21538                         NDR_PULL_ALLOC(ndr, r->in.handle);
21539                 }
21540                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21541                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21542                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21543                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21546                 if (_ptr_buffer) {
21547                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21548                 } else {
21549                         r->in.buffer = NULL;
21550                 }
21551                 if (r->in.buffer) {
21552                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21553                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21554                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21555                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21556                 }
21557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21558                 NDR_PULL_ALLOC(ndr, r->out.needed);
21559                 ZERO_STRUCTP(r->out.needed);
21560         }
21561         if (flags & NDR_OUT) {
21562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21563                 if (_ptr_info) {
21564                         NDR_PULL_ALLOC(ndr, r->out.info);
21565                 } else {
21566                         r->out.info = NULL;
21567                 }
21568                 if (r->out.info) {
21569                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21570                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21571                         {
21572                                 struct ndr_pull *_ndr_info;
21573                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21574                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21575                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21576                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21577                         }
21578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21579                 }
21580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21581                         NDR_PULL_ALLOC(ndr, r->out.needed);
21582                 }
21583                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21584                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21587                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21588         }
21589         return NDR_ERR_SUCCESS;
21590 }
21591
21592 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21593 {
21594         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21595         ndr->depth++;
21596         if (flags & NDR_SET_VALUES) {
21597                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21598         }
21599         if (flags & NDR_IN) {
21600                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21601                 ndr->depth++;
21602                 ndr_print_ptr(ndr, "handle", r->in.handle);
21603                 ndr->depth++;
21604                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21605                 ndr->depth--;
21606                 ndr_print_uint32(ndr, "level", r->in.level);
21607                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21608                 ndr->depth++;
21609                 if (r->in.buffer) {
21610                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21611                 }
21612                 ndr->depth--;
21613                 ndr_print_uint32(ndr, "offered", r->in.offered);
21614                 ndr->depth--;
21615         }
21616         if (flags & NDR_OUT) {
21617                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21618                 ndr->depth++;
21619                 ndr_print_ptr(ndr, "info", r->out.info);
21620                 ndr->depth++;
21621                 if (r->out.info) {
21622                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21623                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21624                 }
21625                 ndr->depth--;
21626                 ndr_print_ptr(ndr, "needed", r->out.needed);
21627                 ndr->depth++;
21628                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21629                 ndr->depth--;
21630                 ndr_print_WERROR(ndr, "result", r->out.result);
21631                 ndr->depth--;
21632         }
21633         ndr->depth--;
21634 }
21635
21636 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21637 {
21638         if (flags & NDR_IN) {
21639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21640                 if (r->in.servername) {
21641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21644                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21645                 }
21646                 if (r->in.info_ctr == NULL) {
21647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21648                 }
21649                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21650         }
21651         if (flags & NDR_OUT) {
21652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21653         }
21654         return NDR_ERR_SUCCESS;
21655 }
21656
21657 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21658 {
21659         uint32_t _ptr_servername;
21660         TALLOC_CTX *_mem_save_servername_0;
21661         TALLOC_CTX *_mem_save_info_ctr_0;
21662         if (flags & NDR_IN) {
21663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21664                 if (_ptr_servername) {
21665                         NDR_PULL_ALLOC(ndr, r->in.servername);
21666                 } else {
21667                         r->in.servername = NULL;
21668                 }
21669                 if (r->in.servername) {
21670                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21671                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21672                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21673                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21674                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21675                                 return 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));
21676                         }
21677                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21678                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21680                 }
21681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21682                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21683                 }
21684                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21685                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21686                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21688         }
21689         if (flags & NDR_OUT) {
21690                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21691         }
21692         return NDR_ERR_SUCCESS;
21693 }
21694
21695 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21696 {
21697         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21698         ndr->depth++;
21699         if (flags & NDR_SET_VALUES) {
21700                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21701         }
21702         if (flags & NDR_IN) {
21703                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21704                 ndr->depth++;
21705                 ndr_print_ptr(ndr, "servername", r->in.servername);
21706                 ndr->depth++;
21707                 if (r->in.servername) {
21708                         ndr_print_string(ndr, "servername", r->in.servername);
21709                 }
21710                 ndr->depth--;
21711                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21712                 ndr->depth++;
21713                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21714                 ndr->depth--;
21715                 ndr->depth--;
21716         }
21717         if (flags & NDR_OUT) {
21718                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21719                 ndr->depth++;
21720                 ndr_print_WERROR(ndr, "result", r->out.result);
21721                 ndr->depth--;
21722         }
21723         ndr->depth--;
21724 }
21725
21726 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21727 {
21728         if (flags & NDR_IN) {
21729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21730                 if (r->in.server) {
21731                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21732                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21734                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21735                 }
21736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21737                 if (r->in.environment) {
21738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21741                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21742                 }
21743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21745                 if (r->in.buffer) {
21746                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21747                 }
21748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21749         }
21750         if (flags & NDR_OUT) {
21751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21752                 if (r->out.info) {
21753                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21754                 }
21755                 if (r->out.needed == NULL) {
21756                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21757                 }
21758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21759                 if (r->out.count == NULL) {
21760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21761                 }
21762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21763                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21764         }
21765         return NDR_ERR_SUCCESS;
21766 }
21767
21768 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21769 {
21770         uint32_t _ptr_server;
21771         uint32_t _ptr_environment;
21772         uint32_t _ptr_buffer;
21773         uint32_t _ptr_info;
21774         TALLOC_CTX *_mem_save_server_0;
21775         TALLOC_CTX *_mem_save_environment_0;
21776         TALLOC_CTX *_mem_save_buffer_0;
21777         TALLOC_CTX *_mem_save_info_0;
21778         TALLOC_CTX *_mem_save_needed_0;
21779         TALLOC_CTX *_mem_save_count_0;
21780         if (flags & NDR_IN) {
21781                 ZERO_STRUCT(r->out);
21782
21783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21784                 if (_ptr_server) {
21785                         NDR_PULL_ALLOC(ndr, r->in.server);
21786                 } else {
21787                         r->in.server = NULL;
21788                 }
21789                 if (r->in.server) {
21790                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21794                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21795                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
21796                         }
21797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21800                 }
21801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21802                 if (_ptr_environment) {
21803                         NDR_PULL_ALLOC(ndr, r->in.environment);
21804                 } else {
21805                         r->in.environment = NULL;
21806                 }
21807                 if (r->in.environment) {
21808                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21809                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21810                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21811                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21812                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21813                                 return 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));
21814                         }
21815                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21816                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21817                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21818                 }
21819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21821                 if (_ptr_buffer) {
21822                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21823                 } else {
21824                         r->in.buffer = NULL;
21825                 }
21826                 if (r->in.buffer) {
21827                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21828                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21829                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21830                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21831                 }
21832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21833                 NDR_PULL_ALLOC(ndr, r->out.needed);
21834                 ZERO_STRUCTP(r->out.needed);
21835                 NDR_PULL_ALLOC(ndr, r->out.count);
21836                 ZERO_STRUCTP(r->out.count);
21837         }
21838         if (flags & NDR_OUT) {
21839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21840                 if (_ptr_info) {
21841                         NDR_PULL_ALLOC(ndr, r->out.info);
21842                 } else {
21843                         r->out.info = NULL;
21844                 }
21845                 if (r->out.info) {
21846                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21847                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21848                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21850                 }
21851                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21852                         NDR_PULL_ALLOC(ndr, r->out.needed);
21853                 }
21854                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21855                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21857                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21859                         NDR_PULL_ALLOC(ndr, r->out.count);
21860                 }
21861                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21862                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21866         }
21867         return NDR_ERR_SUCCESS;
21868 }
21869
21870 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21871 {
21872         uint32_t cntr_info_0;
21873         if (flags & NDR_IN) {
21874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21876         }
21877         if (flags & NDR_OUT) {
21878                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21879                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21880                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21881                 }
21882                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21883                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21884                 }
21885         }
21886         return NDR_ERR_SUCCESS;
21887 }
21888
21889 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21890 {
21891         uint32_t cntr_info_0;
21892         TALLOC_CTX *_mem_save_info_0;
21893         if (flags & NDR_IN) {
21894                 ZERO_STRUCT(r->out);
21895
21896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21898         }
21899         if (flags & NDR_OUT) {
21900                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21901                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21902                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21903                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21904                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21905                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21906                 }
21907                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21908                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21909                 }
21910                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21911         }
21912         return NDR_ERR_SUCCESS;
21913 }
21914
21915 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21916 {
21917         uint32_t cntr_info_2;
21918         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21919         ndr->depth++;
21920         if (flags & NDR_SET_VALUES) {
21921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21922         }
21923         if (flags & NDR_IN) {
21924                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21925                 ndr->depth++;
21926                 ndr_print_ptr(ndr, "server", r->in.server);
21927                 ndr->depth++;
21928                 if (r->in.server) {
21929                         ndr_print_string(ndr, "server", r->in.server);
21930                 }
21931                 ndr->depth--;
21932                 ndr_print_ptr(ndr, "environment", r->in.environment);
21933                 ndr->depth++;
21934                 if (r->in.environment) {
21935                         ndr_print_string(ndr, "environment", r->in.environment);
21936                 }
21937                 ndr->depth--;
21938                 ndr_print_uint32(ndr, "level", r->in.level);
21939                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21940                 ndr->depth++;
21941                 if (r->in.buffer) {
21942                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21943                 }
21944                 ndr->depth--;
21945                 ndr_print_uint32(ndr, "offered", r->in.offered);
21946                 ndr->depth--;
21947         }
21948         if (flags & NDR_OUT) {
21949                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21950                 ndr->depth++;
21951                 ndr_print_ptr(ndr, "count", r->out.count);
21952                 ndr->depth++;
21953                 ndr_print_uint32(ndr, "count", *r->out.count);
21954                 ndr->depth--;
21955                 ndr_print_ptr(ndr, "info", r->out.info);
21956                 ndr->depth++;
21957                 ndr_print_ptr(ndr, "info", *r->out.info);
21958                 ndr->depth++;
21959                 if (*r->out.info) {
21960                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21961                         ndr->depth++;
21962                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21963                                 char *idx_2=NULL;
21964                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21965                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21966                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21967                                         free(idx_2);
21968                                 }
21969                         }
21970                         ndr->depth--;
21971                 }
21972                 ndr->depth--;
21973                 ndr->depth--;
21974                 ndr_print_ptr(ndr, "needed", r->out.needed);
21975                 ndr->depth++;
21976                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21977                 ndr->depth--;
21978                 ndr_print_WERROR(ndr, "result", r->out.result);
21979                 ndr->depth--;
21980         }
21981         ndr->depth--;
21982 }
21983
21984 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21985 {
21986         if (flags & NDR_IN) {
21987                 if (r->in.handle == NULL) {
21988                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21989                 }
21990                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21992                 if (r->in.architecture) {
21993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21996                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21997                 }
21998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22000                 if (r->in.buffer) {
22001                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22002                 }
22003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22004         }
22005         if (flags & NDR_OUT) {
22006                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22007                 if (r->out.info) {
22008                         {
22009                                 struct ndr_push *_ndr_info;
22010                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22011                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22012                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22013                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22014                         }
22015                 }
22016                 if (r->out.needed == NULL) {
22017                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22018                 }
22019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22020                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22021         }
22022         return NDR_ERR_SUCCESS;
22023 }
22024
22025 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
22026 {
22027         uint32_t _ptr_architecture;
22028         uint32_t _ptr_buffer;
22029         uint32_t _ptr_info;
22030         TALLOC_CTX *_mem_save_handle_0;
22031         TALLOC_CTX *_mem_save_architecture_0;
22032         TALLOC_CTX *_mem_save_buffer_0;
22033         TALLOC_CTX *_mem_save_info_0;
22034         TALLOC_CTX *_mem_save_needed_0;
22035         if (flags & NDR_IN) {
22036                 ZERO_STRUCT(r->out);
22037
22038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22039                         NDR_PULL_ALLOC(ndr, r->in.handle);
22040                 }
22041                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22042                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22043                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
22046                 if (_ptr_architecture) {
22047                         NDR_PULL_ALLOC(ndr, r->in.architecture);
22048                 } else {
22049                         r->in.architecture = NULL;
22050                 }
22051                 if (r->in.architecture) {
22052                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
22053                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
22054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22056                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22057                                 return 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));
22058                         }
22059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
22062                 }
22063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22065                 if (_ptr_buffer) {
22066                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22067                 } else {
22068                         r->in.buffer = NULL;
22069                 }
22070                 if (r->in.buffer) {
22071                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22072                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22073                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22075                 }
22076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22077                 NDR_PULL_ALLOC(ndr, r->out.needed);
22078                 ZERO_STRUCTP(r->out.needed);
22079         }
22080         if (flags & NDR_OUT) {
22081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22082                 if (_ptr_info) {
22083                         NDR_PULL_ALLOC(ndr, r->out.info);
22084                 } else {
22085                         r->out.info = NULL;
22086                 }
22087                 if (r->out.info) {
22088                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22089                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22090                         {
22091                                 struct ndr_pull *_ndr_info;
22092                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22093                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22094                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22095                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22096                         }
22097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22098                 }
22099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22100                         NDR_PULL_ALLOC(ndr, r->out.needed);
22101                 }
22102                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22103                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22105                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22106                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22107         }
22108         return NDR_ERR_SUCCESS;
22109 }
22110
22111 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
22112 {
22113         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
22114         ndr->depth++;
22115         if (flags & NDR_SET_VALUES) {
22116                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22117         }
22118         if (flags & NDR_IN) {
22119                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
22120                 ndr->depth++;
22121                 ndr_print_ptr(ndr, "handle", r->in.handle);
22122                 ndr->depth++;
22123                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22124                 ndr->depth--;
22125                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
22126                 ndr->depth++;
22127                 if (r->in.architecture) {
22128                         ndr_print_string(ndr, "architecture", r->in.architecture);
22129                 }
22130                 ndr->depth--;
22131                 ndr_print_uint32(ndr, "level", r->in.level);
22132                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22133                 ndr->depth++;
22134                 if (r->in.buffer) {
22135                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22136                 }
22137                 ndr->depth--;
22138                 ndr_print_uint32(ndr, "offered", r->in.offered);
22139                 ndr->depth--;
22140         }
22141         if (flags & NDR_OUT) {
22142                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
22143                 ndr->depth++;
22144                 ndr_print_ptr(ndr, "info", r->out.info);
22145                 ndr->depth++;
22146                 if (r->out.info) {
22147                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22148                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22149                 }
22150                 ndr->depth--;
22151                 ndr_print_ptr(ndr, "needed", r->out.needed);
22152                 ndr->depth++;
22153                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22154                 ndr->depth--;
22155                 ndr_print_WERROR(ndr, "result", r->out.result);
22156                 ndr->depth--;
22157         }
22158         ndr->depth--;
22159 }
22160
22161 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22162 {
22163         if (flags & NDR_IN) {
22164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22165                 if (r->in.server) {
22166                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22170                 }
22171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22172                 if (r->in.environment) {
22173                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22176                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22177                 }
22178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22179                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22180                 if (r->in.buffer) {
22181                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22182                 }
22183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22184         }
22185         if (flags & NDR_OUT) {
22186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22187                 if (r->out.info) {
22188                         {
22189                                 struct ndr_push *_ndr_info;
22190                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22191                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22192                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22193                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22194                         }
22195                 }
22196                 if (r->out.needed == NULL) {
22197                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22198                 }
22199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22200                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22201         }
22202         return NDR_ERR_SUCCESS;
22203 }
22204
22205 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
22206 {
22207         uint32_t _ptr_server;
22208         uint32_t _ptr_environment;
22209         uint32_t _ptr_buffer;
22210         uint32_t _ptr_info;
22211         TALLOC_CTX *_mem_save_server_0;
22212         TALLOC_CTX *_mem_save_environment_0;
22213         TALLOC_CTX *_mem_save_buffer_0;
22214         TALLOC_CTX *_mem_save_info_0;
22215         TALLOC_CTX *_mem_save_needed_0;
22216         if (flags & NDR_IN) {
22217                 ZERO_STRUCT(r->out);
22218
22219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22220                 if (_ptr_server) {
22221                         NDR_PULL_ALLOC(ndr, r->in.server);
22222                 } else {
22223                         r->in.server = NULL;
22224                 }
22225                 if (r->in.server) {
22226                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22227                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22229                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22230                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22231                                 return 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));
22232                         }
22233                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22234                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22235                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22236                 }
22237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22238                 if (_ptr_environment) {
22239                         NDR_PULL_ALLOC(ndr, r->in.environment);
22240                 } else {
22241                         r->in.environment = NULL;
22242                 }
22243                 if (r->in.environment) {
22244                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22245                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22246                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22247                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22248                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22249                                 return 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));
22250                         }
22251                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22252                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22253                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22254                 }
22255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22257                 if (_ptr_buffer) {
22258                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22259                 } else {
22260                         r->in.buffer = NULL;
22261                 }
22262                 if (r->in.buffer) {
22263                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22264                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22265                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22267                 }
22268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22269                 NDR_PULL_ALLOC(ndr, r->out.needed);
22270                 ZERO_STRUCTP(r->out.needed);
22271         }
22272         if (flags & NDR_OUT) {
22273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22274                 if (_ptr_info) {
22275                         NDR_PULL_ALLOC(ndr, r->out.info);
22276                 } else {
22277                         r->out.info = NULL;
22278                 }
22279                 if (r->out.info) {
22280                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22281                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22282                         {
22283                                 struct ndr_pull *_ndr_info;
22284                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22285                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22286                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22287                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22288                         }
22289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22290                 }
22291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22292                         NDR_PULL_ALLOC(ndr, r->out.needed);
22293                 }
22294                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22295                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22298                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22299         }
22300         return NDR_ERR_SUCCESS;
22301 }
22302
22303 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22304 {
22305         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22306         ndr->depth++;
22307         if (flags & NDR_SET_VALUES) {
22308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22309         }
22310         if (flags & NDR_IN) {
22311                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22312                 ndr->depth++;
22313                 ndr_print_ptr(ndr, "server", r->in.server);
22314                 ndr->depth++;
22315                 if (r->in.server) {
22316                         ndr_print_string(ndr, "server", r->in.server);
22317                 }
22318                 ndr->depth--;
22319                 ndr_print_ptr(ndr, "environment", r->in.environment);
22320                 ndr->depth++;
22321                 if (r->in.environment) {
22322                         ndr_print_string(ndr, "environment", r->in.environment);
22323                 }
22324                 ndr->depth--;
22325                 ndr_print_uint32(ndr, "level", r->in.level);
22326                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22327                 ndr->depth++;
22328                 if (r->in.buffer) {
22329                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22330                 }
22331                 ndr->depth--;
22332                 ndr_print_uint32(ndr, "offered", r->in.offered);
22333                 ndr->depth--;
22334         }
22335         if (flags & NDR_OUT) {
22336                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22337                 ndr->depth++;
22338                 ndr_print_ptr(ndr, "info", r->out.info);
22339                 ndr->depth++;
22340                 if (r->out.info) {
22341                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22342                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22343                 }
22344                 ndr->depth--;
22345                 ndr_print_ptr(ndr, "needed", r->out.needed);
22346                 ndr->depth++;
22347                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22348                 ndr->depth--;
22349                 ndr_print_WERROR(ndr, "result", r->out.result);
22350                 ndr->depth--;
22351         }
22352         ndr->depth--;
22353 }
22354
22355 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22356 {
22357         if (flags & NDR_IN) {
22358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22359                 if (r->in.server) {
22360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22362                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22363                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22364                 }
22365                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22366                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22367                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22368                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22369                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22370                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22371                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22372                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22373         }
22374         if (flags & NDR_OUT) {
22375                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22376         }
22377         return NDR_ERR_SUCCESS;
22378 }
22379
22380 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22381 {
22382         uint32_t _ptr_server;
22383         TALLOC_CTX *_mem_save_server_0;
22384         if (flags & NDR_IN) {
22385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22386                 if (_ptr_server) {
22387                         NDR_PULL_ALLOC(ndr, r->in.server);
22388                 } else {
22389                         r->in.server = NULL;
22390                 }
22391                 if (r->in.server) {
22392                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22393                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22394                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22395                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22396                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22397                                 return 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));
22398                         }
22399                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22400                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22401                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22402                 }
22403                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22404                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22405                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22406                         return 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));
22407                 }
22408                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22409                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22410                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22411                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22412                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22413                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
22414                 }
22415                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22416                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22417         }
22418         if (flags & NDR_OUT) {
22419                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22420         }
22421         return NDR_ERR_SUCCESS;
22422 }
22423
22424 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22425 {
22426         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22427         ndr->depth++;
22428         if (flags & NDR_SET_VALUES) {
22429                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22430         }
22431         if (flags & NDR_IN) {
22432                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22433                 ndr->depth++;
22434                 ndr_print_ptr(ndr, "server", r->in.server);
22435                 ndr->depth++;
22436                 if (r->in.server) {
22437                         ndr_print_string(ndr, "server", r->in.server);
22438                 }
22439                 ndr->depth--;
22440                 ndr_print_string(ndr, "architecture", r->in.architecture);
22441                 ndr_print_string(ndr, "driver", r->in.driver);
22442                 ndr->depth--;
22443         }
22444         if (flags & NDR_OUT) {
22445                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22446                 ndr->depth++;
22447                 ndr_print_WERROR(ndr, "result", r->out.result);
22448                 ndr->depth--;
22449         }
22450         ndr->depth--;
22451 }
22452
22453 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22454 {
22455         if (flags & NDR_IN) {
22456                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22457                 if (r->in.server) {
22458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22462                 }
22463                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22464                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22465                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22466                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22467                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22468                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22469                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22470                 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));
22471                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22472                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22473                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22474                 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));
22475         }
22476         if (flags & NDR_OUT) {
22477                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22478         }
22479         return NDR_ERR_SUCCESS;
22480 }
22481
22482 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22483 {
22484         uint32_t _ptr_server;
22485         TALLOC_CTX *_mem_save_server_0;
22486         if (flags & NDR_IN) {
22487                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22488                 if (_ptr_server) {
22489                         NDR_PULL_ALLOC(ndr, r->in.server);
22490                 } else {
22491                         r->in.server = NULL;
22492                 }
22493                 if (r->in.server) {
22494                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22495                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22496                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22497                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22498                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22499                                 return 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));
22500                         }
22501                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22502                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22504                 }
22505                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22506                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22507                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22508                         return 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));
22509                 }
22510                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22511                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22512                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22513                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22514                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22515                         return 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));
22516                 }
22517                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22518                 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));
22519                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22520                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22521                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22522                         return 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));
22523                 }
22524                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22525                 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));
22526         }
22527         if (flags & NDR_OUT) {
22528                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22529         }
22530         return NDR_ERR_SUCCESS;
22531 }
22532
22533 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22534 {
22535         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22536         ndr->depth++;
22537         if (flags & NDR_SET_VALUES) {
22538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22539         }
22540         if (flags & NDR_IN) {
22541                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22542                 ndr->depth++;
22543                 ndr_print_ptr(ndr, "server", r->in.server);
22544                 ndr->depth++;
22545                 if (r->in.server) {
22546                         ndr_print_string(ndr, "server", r->in.server);
22547                 }
22548                 ndr->depth--;
22549                 ndr_print_string(ndr, "architecture", r->in.architecture);
22550                 ndr_print_string(ndr, "path_name", r->in.path_name);
22551                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22552                 ndr->depth--;
22553         }
22554         if (flags & NDR_OUT) {
22555                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22556                 ndr->depth++;
22557                 ndr_print_WERROR(ndr, "result", r->out.result);
22558                 ndr->depth--;
22559         }
22560         ndr->depth--;
22561 }
22562
22563 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22564 {
22565         if (flags & NDR_IN) {
22566                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22567                 if (r->in.servername) {
22568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22571                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22572                 }
22573                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22574                 if (r->in.environment) {
22575                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22576                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22577                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22578                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22579                 }
22580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22581                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22582                 if (r->in.buffer) {
22583                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22584                 }
22585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22586         }
22587         if (flags & NDR_OUT) {
22588                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22589                 if (r->out.info) {
22590                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22591                 }
22592                 if (r->out.needed == 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.needed));
22596                 if (r->out.count == NULL) {
22597                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22598                 }
22599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22600                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22601         }
22602         return NDR_ERR_SUCCESS;
22603 }
22604
22605 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22606 {
22607         uint32_t _ptr_servername;
22608         uint32_t _ptr_environment;
22609         uint32_t _ptr_buffer;
22610         uint32_t _ptr_info;
22611         TALLOC_CTX *_mem_save_servername_0;
22612         TALLOC_CTX *_mem_save_environment_0;
22613         TALLOC_CTX *_mem_save_buffer_0;
22614         TALLOC_CTX *_mem_save_info_0;
22615         TALLOC_CTX *_mem_save_needed_0;
22616         TALLOC_CTX *_mem_save_count_0;
22617         if (flags & NDR_IN) {
22618                 ZERO_STRUCT(r->out);
22619
22620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22621                 if (_ptr_servername) {
22622                         NDR_PULL_ALLOC(ndr, r->in.servername);
22623                 } else {
22624                         r->in.servername = NULL;
22625                 }
22626                 if (r->in.servername) {
22627                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22628                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22629                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22630                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22631                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22632                                 return 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));
22633                         }
22634                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22635                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22637                 }
22638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22639                 if (_ptr_environment) {
22640                         NDR_PULL_ALLOC(ndr, r->in.environment);
22641                 } else {
22642                         r->in.environment = NULL;
22643                 }
22644                 if (r->in.environment) {
22645                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22646                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22649                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22650                                 return 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));
22651                         }
22652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22655                 }
22656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22658                 if (_ptr_buffer) {
22659                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22660                 } else {
22661                         r->in.buffer = NULL;
22662                 }
22663                 if (r->in.buffer) {
22664                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22665                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22666                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22668                 }
22669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22670                 NDR_PULL_ALLOC(ndr, r->out.needed);
22671                 ZERO_STRUCTP(r->out.needed);
22672                 NDR_PULL_ALLOC(ndr, r->out.count);
22673                 ZERO_STRUCTP(r->out.count);
22674         }
22675         if (flags & NDR_OUT) {
22676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22677                 if (_ptr_info) {
22678                         NDR_PULL_ALLOC(ndr, r->out.info);
22679                 } else {
22680                         r->out.info = NULL;
22681                 }
22682                 if (r->out.info) {
22683                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22684                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22685                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22687                 }
22688                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22689                         NDR_PULL_ALLOC(ndr, r->out.needed);
22690                 }
22691                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22692                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22694                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22695                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22696                         NDR_PULL_ALLOC(ndr, r->out.count);
22697                 }
22698                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22699                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22701                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22702                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22703         }
22704         return NDR_ERR_SUCCESS;
22705 }
22706
22707 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22708 {
22709         uint32_t cntr_info_0;
22710         if (flags & NDR_IN) {
22711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22713         }
22714         if (flags & NDR_OUT) {
22715                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22716                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22717                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22718                 }
22719                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22720                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22721                 }
22722         }
22723         return NDR_ERR_SUCCESS;
22724 }
22725
22726 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22727 {
22728         uint32_t cntr_info_0;
22729         TALLOC_CTX *_mem_save_info_0;
22730         if (flags & NDR_IN) {
22731                 ZERO_STRUCT(r->out);
22732
22733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22735         }
22736         if (flags & NDR_OUT) {
22737                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22738                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22739                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22740                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22741                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22742                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22743                 }
22744                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22745                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22746                 }
22747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22748         }
22749         return NDR_ERR_SUCCESS;
22750 }
22751
22752 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22753 {
22754         uint32_t cntr_info_2;
22755         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22756         ndr->depth++;
22757         if (flags & NDR_SET_VALUES) {
22758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22759         }
22760         if (flags & NDR_IN) {
22761                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22762                 ndr->depth++;
22763                 ndr_print_ptr(ndr, "servername", r->in.servername);
22764                 ndr->depth++;
22765                 if (r->in.servername) {
22766                         ndr_print_string(ndr, "servername", r->in.servername);
22767                 }
22768                 ndr->depth--;
22769                 ndr_print_ptr(ndr, "environment", r->in.environment);
22770                 ndr->depth++;
22771                 if (r->in.environment) {
22772                         ndr_print_string(ndr, "environment", r->in.environment);
22773                 }
22774                 ndr->depth--;
22775                 ndr_print_uint32(ndr, "level", r->in.level);
22776                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22777                 ndr->depth++;
22778                 if (r->in.buffer) {
22779                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22780                 }
22781                 ndr->depth--;
22782                 ndr_print_uint32(ndr, "offered", r->in.offered);
22783                 ndr->depth--;
22784         }
22785         if (flags & NDR_OUT) {
22786                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22787                 ndr->depth++;
22788                 ndr_print_ptr(ndr, "count", r->out.count);
22789                 ndr->depth++;
22790                 ndr_print_uint32(ndr, "count", *r->out.count);
22791                 ndr->depth--;
22792                 ndr_print_ptr(ndr, "info", r->out.info);
22793                 ndr->depth++;
22794                 ndr_print_ptr(ndr, "info", *r->out.info);
22795                 ndr->depth++;
22796                 if (*r->out.info) {
22797                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22798                         ndr->depth++;
22799                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22800                                 char *idx_2=NULL;
22801                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22802                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22803                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22804                                         free(idx_2);
22805                                 }
22806                         }
22807                         ndr->depth--;
22808                 }
22809                 ndr->depth--;
22810                 ndr->depth--;
22811                 ndr_print_ptr(ndr, "needed", r->out.needed);
22812                 ndr->depth++;
22813                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22814                 ndr->depth--;
22815                 ndr_print_WERROR(ndr, "result", r->out.result);
22816                 ndr->depth--;
22817         }
22818         ndr->depth--;
22819 }
22820
22821 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22822 {
22823         if (flags & NDR_IN) {
22824                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22825                 if (r->in.server) {
22826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22830                 }
22831                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22832                 if (r->in.environment) {
22833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22835                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22836                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22837                 }
22838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22839                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22840                 if (r->in.buffer) {
22841                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22842                 }
22843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22844         }
22845         if (flags & NDR_OUT) {
22846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22847                 if (r->out.info) {
22848                         {
22849                                 struct ndr_push *_ndr_info;
22850                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22851                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22852                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22853                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22854                         }
22855                 }
22856                 if (r->out.needed == NULL) {
22857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22858                 }
22859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22860                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22861         }
22862         return NDR_ERR_SUCCESS;
22863 }
22864
22865 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22866 {
22867         uint32_t _ptr_server;
22868         uint32_t _ptr_environment;
22869         uint32_t _ptr_buffer;
22870         uint32_t _ptr_info;
22871         TALLOC_CTX *_mem_save_server_0;
22872         TALLOC_CTX *_mem_save_environment_0;
22873         TALLOC_CTX *_mem_save_buffer_0;
22874         TALLOC_CTX *_mem_save_info_0;
22875         TALLOC_CTX *_mem_save_needed_0;
22876         if (flags & NDR_IN) {
22877                 ZERO_STRUCT(r->out);
22878
22879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22880                 if (_ptr_server) {
22881                         NDR_PULL_ALLOC(ndr, r->in.server);
22882                 } else {
22883                         r->in.server = NULL;
22884                 }
22885                 if (r->in.server) {
22886                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22887                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22889                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22890                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22891                                 return 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));
22892                         }
22893                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22894                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22896                 }
22897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22898                 if (_ptr_environment) {
22899                         NDR_PULL_ALLOC(ndr, r->in.environment);
22900                 } else {
22901                         r->in.environment = NULL;
22902                 }
22903                 if (r->in.environment) {
22904                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22905                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22907                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22908                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22909                                 return 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));
22910                         }
22911                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22914                 }
22915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22917                 if (_ptr_buffer) {
22918                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22919                 } else {
22920                         r->in.buffer = NULL;
22921                 }
22922                 if (r->in.buffer) {
22923                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22924                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22925                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22927                 }
22928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22929                 NDR_PULL_ALLOC(ndr, r->out.needed);
22930                 ZERO_STRUCTP(r->out.needed);
22931         }
22932         if (flags & NDR_OUT) {
22933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22934                 if (_ptr_info) {
22935                         NDR_PULL_ALLOC(ndr, r->out.info);
22936                 } else {
22937                         r->out.info = NULL;
22938                 }
22939                 if (r->out.info) {
22940                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22941                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22942                         {
22943                                 struct ndr_pull *_ndr_info;
22944                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22945                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22946                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22947                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22948                         }
22949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22950                 }
22951                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22952                         NDR_PULL_ALLOC(ndr, r->out.needed);
22953                 }
22954                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22955                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22957                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22958                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22959         }
22960         return NDR_ERR_SUCCESS;
22961 }
22962
22963 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22964 {
22965         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22966         ndr->depth++;
22967         if (flags & NDR_SET_VALUES) {
22968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22969         }
22970         if (flags & NDR_IN) {
22971                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22972                 ndr->depth++;
22973                 ndr_print_ptr(ndr, "server", r->in.server);
22974                 ndr->depth++;
22975                 if (r->in.server) {
22976                         ndr_print_string(ndr, "server", r->in.server);
22977                 }
22978                 ndr->depth--;
22979                 ndr_print_ptr(ndr, "environment", r->in.environment);
22980                 ndr->depth++;
22981                 if (r->in.environment) {
22982                         ndr_print_string(ndr, "environment", r->in.environment);
22983                 }
22984                 ndr->depth--;
22985                 ndr_print_uint32(ndr, "level", r->in.level);
22986                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22987                 ndr->depth++;
22988                 if (r->in.buffer) {
22989                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22990                 }
22991                 ndr->depth--;
22992                 ndr_print_uint32(ndr, "offered", r->in.offered);
22993                 ndr->depth--;
22994         }
22995         if (flags & NDR_OUT) {
22996                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22997                 ndr->depth++;
22998                 ndr_print_ptr(ndr, "info", r->out.info);
22999                 ndr->depth++;
23000                 if (r->out.info) {
23001                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23002                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
23003                 }
23004                 ndr->depth--;
23005                 ndr_print_ptr(ndr, "needed", r->out.needed);
23006                 ndr->depth++;
23007                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23008                 ndr->depth--;
23009                 ndr_print_WERROR(ndr, "result", r->out.result);
23010                 ndr->depth--;
23011         }
23012         ndr->depth--;
23013 }
23014
23015 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
23016 {
23017         if (flags & NDR_IN) {
23018                 if (r->in.handle == NULL) {
23019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23020                 }
23021                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23023                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23024                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23025         }
23026         if (flags & NDR_OUT) {
23027                 if (r->out.job_id == NULL) {
23028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23029                 }
23030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
23031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23032         }
23033         return NDR_ERR_SUCCESS;
23034 }
23035
23036 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
23037 {
23038         TALLOC_CTX *_mem_save_handle_0;
23039         TALLOC_CTX *_mem_save_job_id_0;
23040         if (flags & NDR_IN) {
23041                 ZERO_STRUCT(r->out);
23042
23043                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23044                         NDR_PULL_ALLOC(ndr, r->in.handle);
23045                 }
23046                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23047                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23048                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23049                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23051                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23052                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23053                 NDR_PULL_ALLOC(ndr, r->out.job_id);
23054                 ZERO_STRUCTP(r->out.job_id);
23055         }
23056         if (flags & NDR_OUT) {
23057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23058                         NDR_PULL_ALLOC(ndr, r->out.job_id);
23059                 }
23060                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
23061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
23062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
23063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
23064                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23065         }
23066         return NDR_ERR_SUCCESS;
23067 }
23068
23069 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
23070 {
23071         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
23072         ndr->depth++;
23073         if (flags & NDR_SET_VALUES) {
23074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23075         }
23076         if (flags & NDR_IN) {
23077                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
23078                 ndr->depth++;
23079                 ndr_print_ptr(ndr, "handle", r->in.handle);
23080                 ndr->depth++;
23081                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23082                 ndr->depth--;
23083                 ndr_print_uint32(ndr, "level", r->in.level);
23084                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23085                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
23086                 ndr->depth--;
23087         }
23088         if (flags & NDR_OUT) {
23089                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
23090                 ndr->depth++;
23091                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
23092                 ndr->depth++;
23093                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
23094                 ndr->depth--;
23095                 ndr_print_WERROR(ndr, "result", r->out.result);
23096                 ndr->depth--;
23097         }
23098         ndr->depth--;
23099 }
23100
23101 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *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         }
23109         if (flags & NDR_OUT) {
23110                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23111         }
23112         return NDR_ERR_SUCCESS;
23113 }
23114
23115 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
23116 {
23117         TALLOC_CTX *_mem_save_handle_0;
23118         if (flags & NDR_IN) {
23119                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23120                         NDR_PULL_ALLOC(ndr, r->in.handle);
23121                 }
23122                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23123                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23124                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23125                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23126         }
23127         if (flags & NDR_OUT) {
23128                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23129         }
23130         return NDR_ERR_SUCCESS;
23131 }
23132
23133 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
23134 {
23135         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
23136         ndr->depth++;
23137         if (flags & NDR_SET_VALUES) {
23138                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23139         }
23140         if (flags & NDR_IN) {
23141                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
23142                 ndr->depth++;
23143                 ndr_print_ptr(ndr, "handle", r->in.handle);
23144                 ndr->depth++;
23145                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23146                 ndr->depth--;
23147                 ndr->depth--;
23148         }
23149         if (flags & NDR_OUT) {
23150                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
23151                 ndr->depth++;
23152                 ndr_print_WERROR(ndr, "result", r->out.result);
23153                 ndr->depth--;
23154         }
23155         ndr->depth--;
23156 }
23157
23158 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
23159 {
23160         if (flags & NDR_IN) {
23161                 if (r->in.handle == NULL) {
23162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23163                 }
23164                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23165                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
23167         }
23168         if (flags & NDR_OUT) {
23169                 if (r->out.num_written == NULL) {
23170                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23171                 }
23172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
23173                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23174         }
23175         return NDR_ERR_SUCCESS;
23176 }
23177
23178 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
23179 {
23180         TALLOC_CTX *_mem_save_handle_0;
23181         TALLOC_CTX *_mem_save_num_written_0;
23182         if (flags & NDR_IN) {
23183                 ZERO_STRUCT(r->out);
23184
23185                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23186                         NDR_PULL_ALLOC(ndr, r->in.handle);
23187                 }
23188                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23189                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23190                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23191                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23192                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
23193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
23194                 NDR_PULL_ALLOC(ndr, r->out.num_written);
23195                 ZERO_STRUCTP(r->out.num_written);
23196         }
23197         if (flags & NDR_OUT) {
23198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23199                         NDR_PULL_ALLOC(ndr, r->out.num_written);
23200                 }
23201                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
23202                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
23203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
23204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
23205                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23206         }
23207         return NDR_ERR_SUCCESS;
23208 }
23209
23210 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
23211 {
23212         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
23213         ndr->depth++;
23214         if (flags & NDR_SET_VALUES) {
23215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23216         }
23217         if (flags & NDR_IN) {
23218                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
23219                 ndr->depth++;
23220                 ndr_print_ptr(ndr, "handle", r->in.handle);
23221                 ndr->depth++;
23222                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23223                 ndr->depth--;
23224                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
23225                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
23226                 ndr->depth--;
23227         }
23228         if (flags & NDR_OUT) {
23229                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
23230                 ndr->depth++;
23231                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
23232                 ndr->depth++;
23233                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
23234                 ndr->depth--;
23235                 ndr_print_WERROR(ndr, "result", r->out.result);
23236                 ndr->depth--;
23237         }
23238         ndr->depth--;
23239 }
23240
23241 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
23242 {
23243         if (flags & NDR_IN) {
23244                 if (r->in.handle == NULL) {
23245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23246                 }
23247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23248         }
23249         if (flags & NDR_OUT) {
23250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23251         }
23252         return NDR_ERR_SUCCESS;
23253 }
23254
23255 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
23256 {
23257         TALLOC_CTX *_mem_save_handle_0;
23258         if (flags & NDR_IN) {
23259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23260                         NDR_PULL_ALLOC(ndr, r->in.handle);
23261                 }
23262                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23263                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23264                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23265                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23266         }
23267         if (flags & NDR_OUT) {
23268                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23269         }
23270         return NDR_ERR_SUCCESS;
23271 }
23272
23273 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
23274 {
23275         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
23276         ndr->depth++;
23277         if (flags & NDR_SET_VALUES) {
23278                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23279         }
23280         if (flags & NDR_IN) {
23281                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
23282                 ndr->depth++;
23283                 ndr_print_ptr(ndr, "handle", r->in.handle);
23284                 ndr->depth++;
23285                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23286                 ndr->depth--;
23287                 ndr->depth--;
23288         }
23289         if (flags & NDR_OUT) {
23290                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
23291                 ndr->depth++;
23292                 ndr_print_WERROR(ndr, "result", r->out.result);
23293                 ndr->depth--;
23294         }
23295         ndr->depth--;
23296 }
23297
23298 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
23299 {
23300         if (flags & NDR_IN) {
23301                 if (r->in.handle == NULL) {
23302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23303                 }
23304                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23305         }
23306         if (flags & NDR_OUT) {
23307                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23308         }
23309         return NDR_ERR_SUCCESS;
23310 }
23311
23312 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23313 {
23314         TALLOC_CTX *_mem_save_handle_0;
23315         if (flags & NDR_IN) {
23316                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23317                         NDR_PULL_ALLOC(ndr, r->in.handle);
23318                 }
23319                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23320                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23321                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23322                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23323         }
23324         if (flags & NDR_OUT) {
23325                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23326         }
23327         return NDR_ERR_SUCCESS;
23328 }
23329
23330 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23331 {
23332         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23333         ndr->depth++;
23334         if (flags & NDR_SET_VALUES) {
23335                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23336         }
23337         if (flags & NDR_IN) {
23338                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23339                 ndr->depth++;
23340                 ndr_print_ptr(ndr, "handle", r->in.handle);
23341                 ndr->depth++;
23342                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23343                 ndr->depth--;
23344                 ndr->depth--;
23345         }
23346         if (flags & NDR_OUT) {
23347                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23348                 ndr->depth++;
23349                 ndr_print_WERROR(ndr, "result", r->out.result);
23350                 ndr->depth--;
23351         }
23352         ndr->depth--;
23353 }
23354
23355 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23356 {
23357         if (flags & NDR_IN) {
23358                 if (r->in.handle == NULL) {
23359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23360                 }
23361                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23363         }
23364         if (flags & NDR_OUT) {
23365                 if (r->out.data == NULL) {
23366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23367                 }
23368                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23369                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23370                 if (r->out._data_size == NULL) {
23371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23372                 }
23373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23374                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23375         }
23376         return NDR_ERR_SUCCESS;
23377 }
23378
23379 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23380 {
23381         TALLOC_CTX *_mem_save_handle_0;
23382         TALLOC_CTX *_mem_save__data_size_0;
23383         if (flags & NDR_IN) {
23384                 ZERO_STRUCT(r->out);
23385
23386                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23387                         NDR_PULL_ALLOC(ndr, r->in.handle);
23388                 }
23389                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23390                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23391                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23394                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23395                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23396                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23397                 ZERO_STRUCTP(r->out._data_size);
23398         }
23399         if (flags & NDR_OUT) {
23400                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23401                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23402                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23403                 }
23404                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23406                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23407                 }
23408                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23409                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23412                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23413                 if (r->out.data) {
23414                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23415                 }
23416         }
23417         return NDR_ERR_SUCCESS;
23418 }
23419
23420 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23421 {
23422         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23423         ndr->depth++;
23424         if (flags & NDR_SET_VALUES) {
23425                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23426         }
23427         if (flags & NDR_IN) {
23428                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23429                 ndr->depth++;
23430                 ndr_print_ptr(ndr, "handle", r->in.handle);
23431                 ndr->depth++;
23432                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23433                 ndr->depth--;
23434                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23435                 ndr->depth--;
23436         }
23437         if (flags & NDR_OUT) {
23438                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23439                 ndr->depth++;
23440                 ndr_print_ptr(ndr, "data", r->out.data);
23441                 ndr->depth++;
23442                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23443                 ndr->depth--;
23444                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23445                 ndr->depth++;
23446                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23447                 ndr->depth--;
23448                 ndr_print_WERROR(ndr, "result", r->out.result);
23449                 ndr->depth--;
23450         }
23451         ndr->depth--;
23452 }
23453
23454 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23455 {
23456         if (flags & NDR_IN) {
23457                 if (r->in.handle == NULL) {
23458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23459                 }
23460                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23461         }
23462         if (flags & NDR_OUT) {
23463                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23464         }
23465         return NDR_ERR_SUCCESS;
23466 }
23467
23468 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23469 {
23470         TALLOC_CTX *_mem_save_handle_0;
23471         if (flags & NDR_IN) {
23472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23473                         NDR_PULL_ALLOC(ndr, r->in.handle);
23474                 }
23475                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23479         }
23480         if (flags & NDR_OUT) {
23481                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23482         }
23483         return NDR_ERR_SUCCESS;
23484 }
23485
23486 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23487 {
23488         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23489         ndr->depth++;
23490         if (flags & NDR_SET_VALUES) {
23491                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23492         }
23493         if (flags & NDR_IN) {
23494                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23495                 ndr->depth++;
23496                 ndr_print_ptr(ndr, "handle", r->in.handle);
23497                 ndr->depth++;
23498                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23499                 ndr->depth--;
23500                 ndr->depth--;
23501         }
23502         if (flags & NDR_OUT) {
23503                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23504                 ndr->depth++;
23505                 ndr_print_WERROR(ndr, "result", r->out.result);
23506                 ndr->depth--;
23507         }
23508         ndr->depth--;
23509 }
23510
23511 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23512 {
23513         if (flags & NDR_IN) {
23514                 if (r->in.handle == NULL) {
23515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23516                 }
23517                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23520                 if (r->in.buffer) {
23521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23522                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23523                 }
23524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23525         }
23526         if (flags & NDR_OUT) {
23527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23528                 if (r->out.buffer) {
23529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23530                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23531                 }
23532                 if (r->out.needed == NULL) {
23533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23534                 }
23535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23536                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23537         }
23538         return NDR_ERR_SUCCESS;
23539 }
23540
23541 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23542 {
23543         uint32_t _ptr_buffer;
23544         TALLOC_CTX *_mem_save_handle_0;
23545         TALLOC_CTX *_mem_save_buffer_0;
23546         TALLOC_CTX *_mem_save_needed_0;
23547         if (flags & NDR_IN) {
23548                 ZERO_STRUCT(r->out);
23549
23550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23551                         NDR_PULL_ALLOC(ndr, r->in.handle);
23552                 }
23553                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23554                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23555                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23559                 if (_ptr_buffer) {
23560                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23561                 } else {
23562                         r->in.buffer = NULL;
23563                 }
23564                 if (r->in.buffer) {
23565                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23566                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23568                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23569                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23571                 }
23572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23573                 NDR_PULL_ALLOC(ndr, r->out.needed);
23574                 ZERO_STRUCTP(r->out.needed);
23575                 if (r->in.buffer) {
23576                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23577                 }
23578         }
23579         if (flags & NDR_OUT) {
23580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23581                 if (_ptr_buffer) {
23582                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23583                 } else {
23584                         r->out.buffer = NULL;
23585                 }
23586                 if (r->out.buffer) {
23587                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23588                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23589                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23590                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23591                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23593                 }
23594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23595                         NDR_PULL_ALLOC(ndr, r->out.needed);
23596                 }
23597                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23598                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23602                 if (r->out.buffer) {
23603                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23604                 }
23605         }
23606         return NDR_ERR_SUCCESS;
23607 }
23608
23609 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23610 {
23611         ndr_print_struct(ndr, name, "spoolss_AddJob");
23612         ndr->depth++;
23613         if (flags & NDR_SET_VALUES) {
23614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23615         }
23616         if (flags & NDR_IN) {
23617                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23618                 ndr->depth++;
23619                 ndr_print_ptr(ndr, "handle", r->in.handle);
23620                 ndr->depth++;
23621                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23622                 ndr->depth--;
23623                 ndr_print_uint32(ndr, "level", r->in.level);
23624                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23625                 ndr->depth++;
23626                 if (r->in.buffer) {
23627                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23628                 }
23629                 ndr->depth--;
23630                 ndr_print_uint32(ndr, "offered", r->in.offered);
23631                 ndr->depth--;
23632         }
23633         if (flags & NDR_OUT) {
23634                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23635                 ndr->depth++;
23636                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23637                 ndr->depth++;
23638                 if (r->out.buffer) {
23639                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23640                 }
23641                 ndr->depth--;
23642                 ndr_print_ptr(ndr, "needed", r->out.needed);
23643                 ndr->depth++;
23644                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23645                 ndr->depth--;
23646                 ndr_print_WERROR(ndr, "result", r->out.result);
23647                 ndr->depth--;
23648         }
23649         ndr->depth--;
23650 }
23651
23652 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23653 {
23654         if (flags & NDR_IN) {
23655                 if (r->in.handle == NULL) {
23656                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23657                 }
23658                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23660         }
23661         if (flags & NDR_OUT) {
23662                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23663         }
23664         return NDR_ERR_SUCCESS;
23665 }
23666
23667 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23668 {
23669         TALLOC_CTX *_mem_save_handle_0;
23670         if (flags & NDR_IN) {
23671                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23672                         NDR_PULL_ALLOC(ndr, r->in.handle);
23673                 }
23674                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23675                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23676                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23677                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23679         }
23680         if (flags & NDR_OUT) {
23681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23682         }
23683         return NDR_ERR_SUCCESS;
23684 }
23685
23686 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23687 {
23688         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23689         ndr->depth++;
23690         if (flags & NDR_SET_VALUES) {
23691                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23692         }
23693         if (flags & NDR_IN) {
23694                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23695                 ndr->depth++;
23696                 ndr_print_ptr(ndr, "handle", r->in.handle);
23697                 ndr->depth++;
23698                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23699                 ndr->depth--;
23700                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23701                 ndr->depth--;
23702         }
23703         if (flags & NDR_OUT) {
23704                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23705                 ndr->depth++;
23706                 ndr_print_WERROR(ndr, "result", r->out.result);
23707                 ndr->depth--;
23708         }
23709         ndr->depth--;
23710 }
23711
23712 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
23713 {
23714         if (flags & NDR_IN) {
23715                 if (r->in.handle == NULL) {
23716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23717                 }
23718                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23719                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23720                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23721                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23722                 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));
23723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23724         }
23725         if (flags & NDR_OUT) {
23726                 if (r->out.type == NULL) {
23727                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23728                 }
23729                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23730                 if (r->out.data == NULL) {
23731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23732                 }
23733                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
23734                 if (r->out.needed == NULL) {
23735                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23736                 }
23737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23739         }
23740         return NDR_ERR_SUCCESS;
23741 }
23742
23743 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
23744 {
23745         TALLOC_CTX *_mem_save_handle_0;
23746         TALLOC_CTX *_mem_save_type_0;
23747         TALLOC_CTX *_mem_save_data_0;
23748         TALLOC_CTX *_mem_save_needed_0;
23749         if (flags & NDR_IN) {
23750                 ZERO_STRUCT(r->out);
23751
23752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23753                         NDR_PULL_ALLOC(ndr, r->in.handle);
23754                 }
23755                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23756                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23757                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23759                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23760                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23761                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23762                         return 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));
23763                 }
23764                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23765                 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));
23766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23767                 NDR_PULL_ALLOC(ndr, r->out.type);
23768                 ZERO_STRUCTP(r->out.type);
23769                 NDR_PULL_ALLOC(ndr, r->out.data);
23770                 ZERO_STRUCTP(r->out.data);
23771                 NDR_PULL_ALLOC(ndr, r->out.needed);
23772                 ZERO_STRUCTP(r->out.needed);
23773         }
23774         if (flags & NDR_OUT) {
23775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23776                         NDR_PULL_ALLOC(ndr, r->out.type);
23777                 }
23778                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23779                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23780                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23782                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23783                         NDR_PULL_ALLOC(ndr, r->out.data);
23784                 }
23785                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23786                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23787                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23788                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23789                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23790                         NDR_PULL_ALLOC(ndr, r->out.needed);
23791                 }
23792                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23793                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23795                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23796                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23797         }
23798         return NDR_ERR_SUCCESS;
23799 }
23800
23801 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23802 {
23803         if (flags & NDR_IN) {
23804                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23805         }
23806         if (flags & NDR_OUT) {
23807                 if (r->out.data == NULL) {
23808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23809                 }
23810                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23811                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23812         }
23813         return NDR_ERR_SUCCESS;
23814 }
23815
23816 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23817 {
23818         TALLOC_CTX *_mem_save_data_0;
23819         if (flags & NDR_IN) {
23820                 ZERO_STRUCT(r->out);
23821
23822                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23823                 NDR_PULL_ALLOC(ndr, r->out.data);
23824                 ZERO_STRUCTP(r->out.data);
23825         }
23826         if (flags & NDR_OUT) {
23827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23828                         NDR_PULL_ALLOC(ndr, r->out.data);
23829                 }
23830                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23831                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23832                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23833                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23835         }
23836         return NDR_ERR_SUCCESS;
23837 }
23838
23839 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23840 {
23841         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23842         ndr->depth++;
23843         if (flags & NDR_SET_VALUES) {
23844                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23845         }
23846         if (flags & NDR_IN) {
23847                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23848                 ndr->depth++;
23849                 ndr_print_ptr(ndr, "handle", r->in.handle);
23850                 ndr->depth++;
23851                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23852                 ndr->depth--;
23853                 ndr_print_string(ndr, "value_name", r->in.value_name);
23854                 ndr_print_uint32(ndr, "offered", r->in.offered);
23855                 ndr->depth--;
23856         }
23857         if (flags & NDR_OUT) {
23858                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23859                 ndr->depth++;
23860                 ndr_print_ptr(ndr, "type", r->out.type);
23861                 ndr->depth++;
23862                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23863                 ndr->depth--;
23864                 ndr_print_ptr(ndr, "data", r->out.data);
23865                 ndr->depth++;
23866                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23867                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23868                 ndr->depth--;
23869                 ndr_print_ptr(ndr, "needed", r->out.needed);
23870                 ndr->depth++;
23871                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23872                 ndr->depth--;
23873                 ndr_print_WERROR(ndr, "result", r->out.result);
23874                 ndr->depth--;
23875         }
23876         ndr->depth--;
23877 }
23878
23879 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23880 {
23881         if (flags & NDR_IN) {
23882                 if (r->in.handle == NULL) {
23883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23884                 }
23885                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23886                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23887                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23888                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23889                 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));
23890                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23891                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
23893         }
23894         if (flags & NDR_OUT) {
23895                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23896         }
23897         return NDR_ERR_SUCCESS;
23898 }
23899
23900 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
23901 {
23902         if (flags & NDR_IN) {
23903                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23904         }
23905         if (flags & NDR_OUT) {
23906                 if (r->out.data == NULL) {
23907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23908                 }
23909                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23910                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23911         }
23912         return NDR_ERR_SUCCESS;
23913 }
23914
23915 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23916 {
23917         TALLOC_CTX *_mem_save_handle_0;
23918         if (flags & NDR_IN) {
23919                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23920                         NDR_PULL_ALLOC(ndr, r->in.handle);
23921                 }
23922                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23923                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23924                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23925                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23926                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23927                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23928                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23929                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
23930                 }
23931                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23932                 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));
23933                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23934                 {
23935                         struct ndr_pull *_ndr_data;
23936                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
23937                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
23938                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
23939                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
23940                 }
23941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
23942         }
23943         if (flags & NDR_OUT) {
23944                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23945         }
23946         return NDR_ERR_SUCCESS;
23947 }
23948
23949 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23950 {
23951         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
23952         ndr->depth++;
23953         if (flags & NDR_SET_VALUES) {
23954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23955         }
23956         if (flags & NDR_IN) {
23957                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
23958                 ndr->depth++;
23959                 ndr_print_ptr(ndr, "handle", r->in.handle);
23960                 ndr->depth++;
23961                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23962                 ndr->depth--;
23963                 ndr_print_string(ndr, "value_name", r->in.value_name);
23964                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23965                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
23966                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
23967                 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);
23968                 ndr->depth--;
23969         }
23970         if (flags & NDR_OUT) {
23971                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23972                 ndr->depth++;
23973                 ndr_print_WERROR(ndr, "result", r->out.result);
23974                 ndr->depth--;
23975         }
23976         ndr->depth--;
23977 }
23978
23979 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23980 {
23981         if (flags & NDR_IN) {
23982         }
23983         if (flags & NDR_OUT) {
23984                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23985         }
23986         return NDR_ERR_SUCCESS;
23987 }
23988
23989 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23990 {
23991         if (flags & NDR_IN) {
23992         }
23993         if (flags & NDR_OUT) {
23994                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23995         }
23996         return NDR_ERR_SUCCESS;
23997 }
23998
23999 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
24000 {
24001         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
24002         ndr->depth++;
24003         if (flags & NDR_SET_VALUES) {
24004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24005         }
24006         if (flags & NDR_IN) {
24007                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
24008                 ndr->depth++;
24009                 ndr->depth--;
24010         }
24011         if (flags & NDR_OUT) {
24012                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
24013                 ndr->depth++;
24014                 ndr_print_WERROR(ndr, "result", r->out.result);
24015                 ndr->depth--;
24016         }
24017         ndr->depth--;
24018 }
24019
24020 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
24021 {
24022         if (flags & NDR_IN) {
24023                 if (r->in.handle == NULL) {
24024                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24025                 }
24026                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24027         }
24028         if (flags & NDR_OUT) {
24029                 if (r->out.handle == NULL) {
24030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24031                 }
24032                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24033                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24034         }
24035         return NDR_ERR_SUCCESS;
24036 }
24037
24038 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
24039 {
24040         TALLOC_CTX *_mem_save_handle_0;
24041         if (flags & NDR_IN) {
24042                 ZERO_STRUCT(r->out);
24043
24044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24045                         NDR_PULL_ALLOC(ndr, r->in.handle);
24046                 }
24047                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24048                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24049                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24050                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24051                 NDR_PULL_ALLOC(ndr, r->out.handle);
24052                 *r->out.handle = *r->in.handle;
24053         }
24054         if (flags & NDR_OUT) {
24055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24056                         NDR_PULL_ALLOC(ndr, r->out.handle);
24057                 }
24058                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24059                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24060                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24063         }
24064         return NDR_ERR_SUCCESS;
24065 }
24066
24067 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
24068 {
24069         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
24070         ndr->depth++;
24071         if (flags & NDR_SET_VALUES) {
24072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24073         }
24074         if (flags & NDR_IN) {
24075                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
24076                 ndr->depth++;
24077                 ndr_print_ptr(ndr, "handle", r->in.handle);
24078                 ndr->depth++;
24079                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24080                 ndr->depth--;
24081                 ndr->depth--;
24082         }
24083         if (flags & NDR_OUT) {
24084                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
24085                 ndr->depth++;
24086                 ndr_print_ptr(ndr, "handle", r->out.handle);
24087                 ndr->depth++;
24088                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24089                 ndr->depth--;
24090                 ndr_print_WERROR(ndr, "result", r->out.result);
24091                 ndr->depth--;
24092         }
24093         ndr->depth--;
24094 }
24095
24096 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
24097 {
24098         if (flags & NDR_IN) {
24099                 if (r->in.handle == NULL) {
24100                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24101                 }
24102                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24104                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24105                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24106         }
24107         if (flags & NDR_OUT) {
24108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24109         }
24110         return NDR_ERR_SUCCESS;
24111 }
24112
24113 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
24114 {
24115         TALLOC_CTX *_mem_save_handle_0;
24116         if (flags & NDR_IN) {
24117                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24118                         NDR_PULL_ALLOC(ndr, r->in.handle);
24119                 }
24120                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24121                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24122                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24125                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24126                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24127         }
24128         if (flags & NDR_OUT) {
24129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24130         }
24131         return NDR_ERR_SUCCESS;
24132 }
24133
24134 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
24135 {
24136         ndr_print_struct(ndr, name, "spoolss_AddForm");
24137         ndr->depth++;
24138         if (flags & NDR_SET_VALUES) {
24139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24140         }
24141         if (flags & NDR_IN) {
24142                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
24143                 ndr->depth++;
24144                 ndr_print_ptr(ndr, "handle", r->in.handle);
24145                 ndr->depth++;
24146                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24147                 ndr->depth--;
24148                 ndr_print_uint32(ndr, "level", r->in.level);
24149                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24150                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24151                 ndr->depth--;
24152         }
24153         if (flags & NDR_OUT) {
24154                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
24155                 ndr->depth++;
24156                 ndr_print_WERROR(ndr, "result", r->out.result);
24157                 ndr->depth--;
24158         }
24159         ndr->depth--;
24160 }
24161
24162 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
24163 {
24164         if (flags & NDR_IN) {
24165                 if (r->in.handle == NULL) {
24166                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24167                 }
24168                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24169                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24170                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24171                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24172                 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));
24173         }
24174         if (flags & NDR_OUT) {
24175                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24176         }
24177         return NDR_ERR_SUCCESS;
24178 }
24179
24180 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
24181 {
24182         TALLOC_CTX *_mem_save_handle_0;
24183         if (flags & NDR_IN) {
24184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24185                         NDR_PULL_ALLOC(ndr, r->in.handle);
24186                 }
24187                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24188                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24189                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24191                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24192                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24193                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24194                         return 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));
24195                 }
24196                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24197                 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));
24198         }
24199         if (flags & NDR_OUT) {
24200                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24201         }
24202         return NDR_ERR_SUCCESS;
24203 }
24204
24205 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
24206 {
24207         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
24208         ndr->depth++;
24209         if (flags & NDR_SET_VALUES) {
24210                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24211         }
24212         if (flags & NDR_IN) {
24213                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
24214                 ndr->depth++;
24215                 ndr_print_ptr(ndr, "handle", r->in.handle);
24216                 ndr->depth++;
24217                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24218                 ndr->depth--;
24219                 ndr_print_string(ndr, "form_name", r->in.form_name);
24220                 ndr->depth--;
24221         }
24222         if (flags & NDR_OUT) {
24223                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
24224                 ndr->depth++;
24225                 ndr_print_WERROR(ndr, "result", r->out.result);
24226                 ndr->depth--;
24227         }
24228         ndr->depth--;
24229 }
24230
24231 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
24232 {
24233         if (flags & NDR_IN) {
24234                 if (r->in.handle == NULL) {
24235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24236                 }
24237                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24238                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24239                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24240                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24241                 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));
24242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24243                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24244                 if (r->in.buffer) {
24245                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24246                 }
24247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24248         }
24249         if (flags & NDR_OUT) {
24250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24251                 if (r->out.info) {
24252                         {
24253                                 struct ndr_push *_ndr_info;
24254                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24255                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24256                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24257                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24258                         }
24259                 }
24260                 if (r->out.needed == NULL) {
24261                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24262                 }
24263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24264                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24265         }
24266         return NDR_ERR_SUCCESS;
24267 }
24268
24269 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
24270 {
24271         uint32_t _ptr_buffer;
24272         uint32_t _ptr_info;
24273         TALLOC_CTX *_mem_save_handle_0;
24274         TALLOC_CTX *_mem_save_buffer_0;
24275         TALLOC_CTX *_mem_save_info_0;
24276         TALLOC_CTX *_mem_save_needed_0;
24277         if (flags & NDR_IN) {
24278                 ZERO_STRUCT(r->out);
24279
24280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24281                         NDR_PULL_ALLOC(ndr, r->in.handle);
24282                 }
24283                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24287                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24288                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24289                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24290                         return 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));
24291                 }
24292                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24293                 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));
24294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24296                 if (_ptr_buffer) {
24297                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24298                 } else {
24299                         r->in.buffer = NULL;
24300                 }
24301                 if (r->in.buffer) {
24302                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24303                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24304                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24306                 }
24307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24308                 NDR_PULL_ALLOC(ndr, r->out.needed);
24309                 ZERO_STRUCTP(r->out.needed);
24310         }
24311         if (flags & NDR_OUT) {
24312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24313                 if (_ptr_info) {
24314                         NDR_PULL_ALLOC(ndr, r->out.info);
24315                 } else {
24316                         r->out.info = NULL;
24317                 }
24318                 if (r->out.info) {
24319                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24320                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24321                         {
24322                                 struct ndr_pull *_ndr_info;
24323                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24324                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24325                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24326                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24327                         }
24328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24329                 }
24330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24331                         NDR_PULL_ALLOC(ndr, r->out.needed);
24332                 }
24333                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24334                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24338         }
24339         return NDR_ERR_SUCCESS;
24340 }
24341
24342 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
24343 {
24344         ndr_print_struct(ndr, name, "spoolss_GetForm");
24345         ndr->depth++;
24346         if (flags & NDR_SET_VALUES) {
24347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24348         }
24349         if (flags & NDR_IN) {
24350                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
24351                 ndr->depth++;
24352                 ndr_print_ptr(ndr, "handle", r->in.handle);
24353                 ndr->depth++;
24354                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24355                 ndr->depth--;
24356                 ndr_print_string(ndr, "form_name", r->in.form_name);
24357                 ndr_print_uint32(ndr, "level", r->in.level);
24358                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24359                 ndr->depth++;
24360                 if (r->in.buffer) {
24361                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24362                 }
24363                 ndr->depth--;
24364                 ndr_print_uint32(ndr, "offered", r->in.offered);
24365                 ndr->depth--;
24366         }
24367         if (flags & NDR_OUT) {
24368                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24369                 ndr->depth++;
24370                 ndr_print_ptr(ndr, "info", r->out.info);
24371                 ndr->depth++;
24372                 if (r->out.info) {
24373                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24374                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24375                 }
24376                 ndr->depth--;
24377                 ndr_print_ptr(ndr, "needed", r->out.needed);
24378                 ndr->depth++;
24379                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24380                 ndr->depth--;
24381                 ndr_print_WERROR(ndr, "result", r->out.result);
24382                 ndr->depth--;
24383         }
24384         ndr->depth--;
24385 }
24386
24387 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24388 {
24389         if (flags & NDR_IN) {
24390                 if (r->in.handle == NULL) {
24391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24392                 }
24393                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24394                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24395                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24396                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24397                 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));
24398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24399                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24400                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24401         }
24402         if (flags & NDR_OUT) {
24403                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24404         }
24405         return NDR_ERR_SUCCESS;
24406 }
24407
24408 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24409 {
24410         TALLOC_CTX *_mem_save_handle_0;
24411         if (flags & NDR_IN) {
24412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24413                         NDR_PULL_ALLOC(ndr, r->in.handle);
24414                 }
24415                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24416                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24417                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24419                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24420                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24421                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24422                         return 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));
24423                 }
24424                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24425                 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));
24426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24427                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24428                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24429         }
24430         if (flags & NDR_OUT) {
24431                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24432         }
24433         return NDR_ERR_SUCCESS;
24434 }
24435
24436 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24437 {
24438         ndr_print_struct(ndr, name, "spoolss_SetForm");
24439         ndr->depth++;
24440         if (flags & NDR_SET_VALUES) {
24441                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24442         }
24443         if (flags & NDR_IN) {
24444                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24445                 ndr->depth++;
24446                 ndr_print_ptr(ndr, "handle", r->in.handle);
24447                 ndr->depth++;
24448                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24449                 ndr->depth--;
24450                 ndr_print_string(ndr, "form_name", r->in.form_name);
24451                 ndr_print_uint32(ndr, "level", r->in.level);
24452                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24453                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24454                 ndr->depth--;
24455         }
24456         if (flags & NDR_OUT) {
24457                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24458                 ndr->depth++;
24459                 ndr_print_WERROR(ndr, "result", r->out.result);
24460                 ndr->depth--;
24461         }
24462         ndr->depth--;
24463 }
24464
24465 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24466 {
24467         if (flags & NDR_IN) {
24468                 if (r->in.handle == NULL) {
24469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24470                 }
24471                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24473                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24474                 if (r->in.buffer) {
24475                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24476                 }
24477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24478         }
24479         if (flags & NDR_OUT) {
24480                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24481                 if (r->out.info) {
24482                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24483                 }
24484                 if (r->out.needed == NULL) {
24485                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24486                 }
24487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24488                 if (r->out.count == NULL) {
24489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24490                 }
24491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24492                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24493         }
24494         return NDR_ERR_SUCCESS;
24495 }
24496
24497 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24498 {
24499         uint32_t _ptr_buffer;
24500         uint32_t _ptr_info;
24501         TALLOC_CTX *_mem_save_handle_0;
24502         TALLOC_CTX *_mem_save_buffer_0;
24503         TALLOC_CTX *_mem_save_info_0;
24504         TALLOC_CTX *_mem_save_needed_0;
24505         TALLOC_CTX *_mem_save_count_0;
24506         if (flags & NDR_IN) {
24507                 ZERO_STRUCT(r->out);
24508
24509                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24510                         NDR_PULL_ALLOC(ndr, r->in.handle);
24511                 }
24512                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24513                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24514                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24515                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24518                 if (_ptr_buffer) {
24519                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24520                 } else {
24521                         r->in.buffer = NULL;
24522                 }
24523                 if (r->in.buffer) {
24524                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24525                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24526                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24528                 }
24529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24530                 NDR_PULL_ALLOC(ndr, r->out.needed);
24531                 ZERO_STRUCTP(r->out.needed);
24532                 NDR_PULL_ALLOC(ndr, r->out.count);
24533                 ZERO_STRUCTP(r->out.count);
24534         }
24535         if (flags & NDR_OUT) {
24536                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24537                 if (_ptr_info) {
24538                         NDR_PULL_ALLOC(ndr, r->out.info);
24539                 } else {
24540                         r->out.info = NULL;
24541                 }
24542                 if (r->out.info) {
24543                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24544                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24545                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24547                 }
24548                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24549                         NDR_PULL_ALLOC(ndr, r->out.needed);
24550                 }
24551                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24552                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24554                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24556                         NDR_PULL_ALLOC(ndr, r->out.count);
24557                 }
24558                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24559                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24563         }
24564         return NDR_ERR_SUCCESS;
24565 }
24566
24567 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24568 {
24569         uint32_t cntr_info_0;
24570         if (flags & NDR_IN) {
24571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24573         }
24574         if (flags & NDR_OUT) {
24575                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24576                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24577                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24578                 }
24579                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24580                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24581                 }
24582         }
24583         return NDR_ERR_SUCCESS;
24584 }
24585
24586 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24587 {
24588         uint32_t cntr_info_0;
24589         TALLOC_CTX *_mem_save_info_0;
24590         if (flags & NDR_IN) {
24591                 ZERO_STRUCT(r->out);
24592
24593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24595         }
24596         if (flags & NDR_OUT) {
24597                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24598                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24599                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24600                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24601                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24602                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24603                 }
24604                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24605                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24606                 }
24607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24608         }
24609         return NDR_ERR_SUCCESS;
24610 }
24611
24612 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24613 {
24614         uint32_t cntr_info_2;
24615         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24616         ndr->depth++;
24617         if (flags & NDR_SET_VALUES) {
24618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24619         }
24620         if (flags & NDR_IN) {
24621                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24622                 ndr->depth++;
24623                 ndr_print_ptr(ndr, "handle", r->in.handle);
24624                 ndr->depth++;
24625                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24626                 ndr->depth--;
24627                 ndr_print_uint32(ndr, "level", r->in.level);
24628                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24629                 ndr->depth++;
24630                 if (r->in.buffer) {
24631                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24632                 }
24633                 ndr->depth--;
24634                 ndr_print_uint32(ndr, "offered", r->in.offered);
24635                 ndr->depth--;
24636         }
24637         if (flags & NDR_OUT) {
24638                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24639                 ndr->depth++;
24640                 ndr_print_ptr(ndr, "count", r->out.count);
24641                 ndr->depth++;
24642                 ndr_print_uint32(ndr, "count", *r->out.count);
24643                 ndr->depth--;
24644                 ndr_print_ptr(ndr, "info", r->out.info);
24645                 ndr->depth++;
24646                 ndr_print_ptr(ndr, "info", *r->out.info);
24647                 ndr->depth++;
24648                 if (*r->out.info) {
24649                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24650                         ndr->depth++;
24651                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24652                                 char *idx_2=NULL;
24653                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24654                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24655                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24656                                         free(idx_2);
24657                                 }
24658                         }
24659                         ndr->depth--;
24660                 }
24661                 ndr->depth--;
24662                 ndr->depth--;
24663                 ndr_print_ptr(ndr, "needed", r->out.needed);
24664                 ndr->depth++;
24665                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24666                 ndr->depth--;
24667                 ndr_print_WERROR(ndr, "result", r->out.result);
24668                 ndr->depth--;
24669         }
24670         ndr->depth--;
24671 }
24672
24673 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24674 {
24675         if (flags & NDR_IN) {
24676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24677                 if (r->in.servername) {
24678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24679                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24681                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24682                 }
24683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24685                 if (r->in.buffer) {
24686                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24687                 }
24688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24689         }
24690         if (flags & NDR_OUT) {
24691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24692                 if (r->out.info) {
24693                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24694                 }
24695                 if (r->out.needed == NULL) {
24696                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24697                 }
24698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24699                 if (r->out.count == NULL) {
24700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24701                 }
24702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24703                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24704         }
24705         return NDR_ERR_SUCCESS;
24706 }
24707
24708 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24709 {
24710         uint32_t _ptr_servername;
24711         uint32_t _ptr_buffer;
24712         uint32_t _ptr_info;
24713         TALLOC_CTX *_mem_save_servername_0;
24714         TALLOC_CTX *_mem_save_buffer_0;
24715         TALLOC_CTX *_mem_save_info_0;
24716         TALLOC_CTX *_mem_save_needed_0;
24717         TALLOC_CTX *_mem_save_count_0;
24718         if (flags & NDR_IN) {
24719                 ZERO_STRUCT(r->out);
24720
24721                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24722                 if (_ptr_servername) {
24723                         NDR_PULL_ALLOC(ndr, r->in.servername);
24724                 } else {
24725                         r->in.servername = NULL;
24726                 }
24727                 if (r->in.servername) {
24728                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24729                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24730                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24731                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24732                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24733                                 return 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));
24734                         }
24735                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24736                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24738                 }
24739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24740                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24741                 if (_ptr_buffer) {
24742                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24743                 } else {
24744                         r->in.buffer = NULL;
24745                 }
24746                 if (r->in.buffer) {
24747                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24748                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24749                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24751                 }
24752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24753                 NDR_PULL_ALLOC(ndr, r->out.needed);
24754                 ZERO_STRUCTP(r->out.needed);
24755                 NDR_PULL_ALLOC(ndr, r->out.count);
24756                 ZERO_STRUCTP(r->out.count);
24757         }
24758         if (flags & NDR_OUT) {
24759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24760                 if (_ptr_info) {
24761                         NDR_PULL_ALLOC(ndr, r->out.info);
24762                 } else {
24763                         r->out.info = NULL;
24764                 }
24765                 if (r->out.info) {
24766                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24767                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24768                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24770                 }
24771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24772                         NDR_PULL_ALLOC(ndr, r->out.needed);
24773                 }
24774                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24775                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24779                         NDR_PULL_ALLOC(ndr, r->out.count);
24780                 }
24781                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24782                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24784                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24785                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24786         }
24787         return NDR_ERR_SUCCESS;
24788 }
24789
24790 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24791 {
24792         uint32_t cntr_info_0;
24793         if (flags & NDR_IN) {
24794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24796         }
24797         if (flags & NDR_OUT) {
24798                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24799                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24800                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24801                 }
24802                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24803                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24804                 }
24805         }
24806         return NDR_ERR_SUCCESS;
24807 }
24808
24809 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24810 {
24811         uint32_t cntr_info_0;
24812         TALLOC_CTX *_mem_save_info_0;
24813         if (flags & NDR_IN) {
24814                 ZERO_STRUCT(r->out);
24815
24816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24818         }
24819         if (flags & NDR_OUT) {
24820                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24821                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24822                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24823                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24824                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24825                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24826                 }
24827                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24828                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24829                 }
24830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24831         }
24832         return NDR_ERR_SUCCESS;
24833 }
24834
24835 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24836 {
24837         uint32_t cntr_info_2;
24838         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24839         ndr->depth++;
24840         if (flags & NDR_SET_VALUES) {
24841                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24842         }
24843         if (flags & NDR_IN) {
24844                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24845                 ndr->depth++;
24846                 ndr_print_ptr(ndr, "servername", r->in.servername);
24847                 ndr->depth++;
24848                 if (r->in.servername) {
24849                         ndr_print_string(ndr, "servername", r->in.servername);
24850                 }
24851                 ndr->depth--;
24852                 ndr_print_uint32(ndr, "level", r->in.level);
24853                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24854                 ndr->depth++;
24855                 if (r->in.buffer) {
24856                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24857                 }
24858                 ndr->depth--;
24859                 ndr_print_uint32(ndr, "offered", r->in.offered);
24860                 ndr->depth--;
24861         }
24862         if (flags & NDR_OUT) {
24863                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24864                 ndr->depth++;
24865                 ndr_print_ptr(ndr, "count", r->out.count);
24866                 ndr->depth++;
24867                 ndr_print_uint32(ndr, "count", *r->out.count);
24868                 ndr->depth--;
24869                 ndr_print_ptr(ndr, "info", r->out.info);
24870                 ndr->depth++;
24871                 ndr_print_ptr(ndr, "info", *r->out.info);
24872                 ndr->depth++;
24873                 if (*r->out.info) {
24874                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24875                         ndr->depth++;
24876                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24877                                 char *idx_2=NULL;
24878                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24879                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24880                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24881                                         free(idx_2);
24882                                 }
24883                         }
24884                         ndr->depth--;
24885                 }
24886                 ndr->depth--;
24887                 ndr->depth--;
24888                 ndr_print_ptr(ndr, "needed", r->out.needed);
24889                 ndr->depth++;
24890                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24891                 ndr->depth--;
24892                 ndr_print_WERROR(ndr, "result", r->out.result);
24893                 ndr->depth--;
24894         }
24895         ndr->depth--;
24896 }
24897
24898 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24899 {
24900         if (flags & NDR_IN) {
24901                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24902                 if (r->in.servername) {
24903                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24905                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24907                 }
24908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24910                 if (r->in.buffer) {
24911                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24912                 }
24913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24914         }
24915         if (flags & NDR_OUT) {
24916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24917                 if (r->out.info) {
24918                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24919                 }
24920                 if (r->out.needed == NULL) {
24921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24922                 }
24923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24924                 if (r->out.count == NULL) {
24925                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24926                 }
24927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24929         }
24930         return NDR_ERR_SUCCESS;
24931 }
24932
24933 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24934 {
24935         uint32_t _ptr_servername;
24936         uint32_t _ptr_buffer;
24937         uint32_t _ptr_info;
24938         TALLOC_CTX *_mem_save_servername_0;
24939         TALLOC_CTX *_mem_save_buffer_0;
24940         TALLOC_CTX *_mem_save_info_0;
24941         TALLOC_CTX *_mem_save_needed_0;
24942         TALLOC_CTX *_mem_save_count_0;
24943         if (flags & NDR_IN) {
24944                 ZERO_STRUCT(r->out);
24945
24946                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24947                 if (_ptr_servername) {
24948                         NDR_PULL_ALLOC(ndr, r->in.servername);
24949                 } else {
24950                         r->in.servername = NULL;
24951                 }
24952                 if (r->in.servername) {
24953                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24954                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24955                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24956                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24957                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24958                                 return 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));
24959                         }
24960                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24961                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24963                 }
24964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24966                 if (_ptr_buffer) {
24967                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24968                 } else {
24969                         r->in.buffer = NULL;
24970                 }
24971                 if (r->in.buffer) {
24972                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24973                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24974                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24976                 }
24977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24978                 NDR_PULL_ALLOC(ndr, r->out.needed);
24979                 ZERO_STRUCTP(r->out.needed);
24980                 NDR_PULL_ALLOC(ndr, r->out.count);
24981                 ZERO_STRUCTP(r->out.count);
24982         }
24983         if (flags & NDR_OUT) {
24984                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24985                 if (_ptr_info) {
24986                         NDR_PULL_ALLOC(ndr, r->out.info);
24987                 } else {
24988                         r->out.info = NULL;
24989                 }
24990                 if (r->out.info) {
24991                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24992                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24993                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24994                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24995                 }
24996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24997                         NDR_PULL_ALLOC(ndr, r->out.needed);
24998                 }
24999                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25000                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25004                         NDR_PULL_ALLOC(ndr, r->out.count);
25005                 }
25006                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25007                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25011         }
25012         return NDR_ERR_SUCCESS;
25013 }
25014
25015 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
25016 {
25017         uint32_t cntr_info_0;
25018         if (flags & NDR_IN) {
25019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25021         }
25022         if (flags & NDR_OUT) {
25023                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25024                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25025                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25026                 }
25027                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25028                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25029                 }
25030         }
25031         return NDR_ERR_SUCCESS;
25032 }
25033
25034 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
25035 {
25036         uint32_t cntr_info_0;
25037         TALLOC_CTX *_mem_save_info_0;
25038         if (flags & NDR_IN) {
25039                 ZERO_STRUCT(r->out);
25040
25041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25042                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25043         }
25044         if (flags & NDR_OUT) {
25045                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25046                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25047                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25048                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25049                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25050                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25051                 }
25052                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25053                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25054                 }
25055                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25056         }
25057         return NDR_ERR_SUCCESS;
25058 }
25059
25060 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
25061 {
25062         uint32_t cntr_info_2;
25063         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
25064         ndr->depth++;
25065         if (flags & NDR_SET_VALUES) {
25066                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25067         }
25068         if (flags & NDR_IN) {
25069                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
25070                 ndr->depth++;
25071                 ndr_print_ptr(ndr, "servername", r->in.servername);
25072                 ndr->depth++;
25073                 if (r->in.servername) {
25074                         ndr_print_string(ndr, "servername", r->in.servername);
25075                 }
25076                 ndr->depth--;
25077                 ndr_print_uint32(ndr, "level", r->in.level);
25078                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25079                 ndr->depth++;
25080                 if (r->in.buffer) {
25081                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25082                 }
25083                 ndr->depth--;
25084                 ndr_print_uint32(ndr, "offered", r->in.offered);
25085                 ndr->depth--;
25086         }
25087         if (flags & NDR_OUT) {
25088                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
25089                 ndr->depth++;
25090                 ndr_print_ptr(ndr, "count", r->out.count);
25091                 ndr->depth++;
25092                 ndr_print_uint32(ndr, "count", *r->out.count);
25093                 ndr->depth--;
25094                 ndr_print_ptr(ndr, "info", r->out.info);
25095                 ndr->depth++;
25096                 ndr_print_ptr(ndr, "info", *r->out.info);
25097                 ndr->depth++;
25098                 if (*r->out.info) {
25099                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25100                         ndr->depth++;
25101                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25102                                 char *idx_2=NULL;
25103                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25104                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25105                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25106                                         free(idx_2);
25107                                 }
25108                         }
25109                         ndr->depth--;
25110                 }
25111                 ndr->depth--;
25112                 ndr->depth--;
25113                 ndr_print_ptr(ndr, "needed", r->out.needed);
25114                 ndr->depth++;
25115                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25116                 ndr->depth--;
25117                 ndr_print_WERROR(ndr, "result", r->out.result);
25118                 ndr->depth--;
25119         }
25120         ndr->depth--;
25121 }
25122
25123 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
25124 {
25125         if (flags & NDR_IN) {
25126                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
25127                 if (r->in.server_name) {
25128                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25129                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25130                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25131                         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));
25132                 }
25133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
25134                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25135                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25136                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25137                 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));
25138         }
25139         if (flags & NDR_OUT) {
25140                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25141         }
25142         return NDR_ERR_SUCCESS;
25143 }
25144
25145 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
25146 {
25147         uint32_t _ptr_server_name;
25148         TALLOC_CTX *_mem_save_server_name_0;
25149         if (flags & NDR_IN) {
25150                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
25151                 if (_ptr_server_name) {
25152                         NDR_PULL_ALLOC(ndr, r->in.server_name);
25153                 } else {
25154                         r->in.server_name = NULL;
25155                 }
25156                 if (r->in.server_name) {
25157                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25158                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
25159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25161                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25162                                 return 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));
25163                         }
25164                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25165                         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));
25166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
25167                 }
25168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
25169                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
25170                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
25171                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
25172                         return 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));
25173                 }
25174                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
25175                 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));
25176         }
25177         if (flags & NDR_OUT) {
25178                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25179         }
25180         return NDR_ERR_SUCCESS;
25181 }
25182
25183 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
25184 {
25185         ndr_print_struct(ndr, name, "spoolss_AddPort");
25186         ndr->depth++;
25187         if (flags & NDR_SET_VALUES) {
25188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25189         }
25190         if (flags & NDR_IN) {
25191                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
25192                 ndr->depth++;
25193                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
25194                 ndr->depth++;
25195                 if (r->in.server_name) {
25196                         ndr_print_string(ndr, "server_name", r->in.server_name);
25197                 }
25198                 ndr->depth--;
25199                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
25200                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
25201                 ndr->depth--;
25202         }
25203         if (flags & NDR_OUT) {
25204                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
25205                 ndr->depth++;
25206                 ndr_print_WERROR(ndr, "result", r->out.result);
25207                 ndr->depth--;
25208         }
25209         ndr->depth--;
25210 }
25211
25212 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
25213 {
25214         if (flags & NDR_IN) {
25215         }
25216         if (flags & NDR_OUT) {
25217                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25218         }
25219         return NDR_ERR_SUCCESS;
25220 }
25221
25222 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
25223 {
25224         if (flags & NDR_IN) {
25225         }
25226         if (flags & NDR_OUT) {
25227                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25228         }
25229         return NDR_ERR_SUCCESS;
25230 }
25231
25232 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
25233 {
25234         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
25235         ndr->depth++;
25236         if (flags & NDR_SET_VALUES) {
25237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25238         }
25239         if (flags & NDR_IN) {
25240                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
25241                 ndr->depth++;
25242                 ndr->depth--;
25243         }
25244         if (flags & NDR_OUT) {
25245                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
25246                 ndr->depth++;
25247                 ndr_print_WERROR(ndr, "result", r->out.result);
25248                 ndr->depth--;
25249         }
25250         ndr->depth--;
25251 }
25252
25253 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
25254 {
25255         if (flags & NDR_IN) {
25256         }
25257         if (flags & NDR_OUT) {
25258                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25259         }
25260         return NDR_ERR_SUCCESS;
25261 }
25262
25263 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
25264 {
25265         if (flags & NDR_IN) {
25266         }
25267         if (flags & NDR_OUT) {
25268                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25269         }
25270         return NDR_ERR_SUCCESS;
25271 }
25272
25273 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
25274 {
25275         ndr_print_struct(ndr, name, "spoolss_DeletePort");
25276         ndr->depth++;
25277         if (flags & NDR_SET_VALUES) {
25278                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25279         }
25280         if (flags & NDR_IN) {
25281                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
25282                 ndr->depth++;
25283                 ndr->depth--;
25284         }
25285         if (flags & NDR_OUT) {
25286                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
25287                 ndr->depth++;
25288                 ndr_print_WERROR(ndr, "result", r->out.result);
25289                 ndr->depth--;
25290         }
25291         ndr->depth--;
25292 }
25293
25294 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
25295 {
25296         if (flags & NDR_IN) {
25297                 if (r->in.handle == NULL) {
25298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25299                 }
25300                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25301                 if (r->in.devmode_ctr == NULL) {
25302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25303                 }
25304                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25305         }
25306         if (flags & NDR_OUT) {
25307                 if (r->out.gdi_handle == NULL) {
25308                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25309                 }
25310                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25311                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25312         }
25313         return NDR_ERR_SUCCESS;
25314 }
25315
25316 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
25317 {
25318         TALLOC_CTX *_mem_save_handle_0;
25319         TALLOC_CTX *_mem_save_gdi_handle_0;
25320         TALLOC_CTX *_mem_save_devmode_ctr_0;
25321         if (flags & NDR_IN) {
25322                 ZERO_STRUCT(r->out);
25323
25324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25325                         NDR_PULL_ALLOC(ndr, r->in.handle);
25326                 }
25327                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25328                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25329                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25331                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25332                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25333                 }
25334                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25335                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25336                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25337                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25338                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25339                 ZERO_STRUCTP(r->out.gdi_handle);
25340         }
25341         if (flags & NDR_OUT) {
25342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25343                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25344                 }
25345                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25346                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25347                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25349                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25350         }
25351         return NDR_ERR_SUCCESS;
25352 }
25353
25354 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25355 {
25356         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25357         ndr->depth++;
25358         if (flags & NDR_SET_VALUES) {
25359                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25360         }
25361         if (flags & NDR_IN) {
25362                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25363                 ndr->depth++;
25364                 ndr_print_ptr(ndr, "handle", r->in.handle);
25365                 ndr->depth++;
25366                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25367                 ndr->depth--;
25368                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25369                 ndr->depth++;
25370                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25371                 ndr->depth--;
25372                 ndr->depth--;
25373         }
25374         if (flags & NDR_OUT) {
25375                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25376                 ndr->depth++;
25377                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25378                 ndr->depth++;
25379                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25380                 ndr->depth--;
25381                 ndr_print_WERROR(ndr, "result", r->out.result);
25382                 ndr->depth--;
25383         }
25384         ndr->depth--;
25385 }
25386
25387 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25388 {
25389         if (flags & NDR_IN) {
25390         }
25391         if (flags & NDR_OUT) {
25392                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25393         }
25394         return NDR_ERR_SUCCESS;
25395 }
25396
25397 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25398 {
25399         if (flags & NDR_IN) {
25400         }
25401         if (flags & NDR_OUT) {
25402                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25403         }
25404         return NDR_ERR_SUCCESS;
25405 }
25406
25407 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25408 {
25409         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25410         ndr->depth++;
25411         if (flags & NDR_SET_VALUES) {
25412                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25413         }
25414         if (flags & NDR_IN) {
25415                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25416                 ndr->depth++;
25417                 ndr->depth--;
25418         }
25419         if (flags & NDR_OUT) {
25420                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25421                 ndr->depth++;
25422                 ndr_print_WERROR(ndr, "result", r->out.result);
25423                 ndr->depth--;
25424         }
25425         ndr->depth--;
25426 }
25427
25428 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25429 {
25430         if (flags & NDR_IN) {
25431                 if (r->in.gdi_handle == NULL) {
25432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25433                 }
25434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25435         }
25436         if (flags & NDR_OUT) {
25437                 if (r->out.gdi_handle == NULL) {
25438                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25439                 }
25440                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25441                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25442         }
25443         return NDR_ERR_SUCCESS;
25444 }
25445
25446 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25447 {
25448         TALLOC_CTX *_mem_save_gdi_handle_0;
25449         if (flags & NDR_IN) {
25450                 ZERO_STRUCT(r->out);
25451
25452                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25453                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25454                 }
25455                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25456                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25457                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25459                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25460                 *r->out.gdi_handle = *r->in.gdi_handle;
25461         }
25462         if (flags & NDR_OUT) {
25463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25464                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25465                 }
25466                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25467                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25468                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25470                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25471         }
25472         return NDR_ERR_SUCCESS;
25473 }
25474
25475 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25476 {
25477         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25478         ndr->depth++;
25479         if (flags & NDR_SET_VALUES) {
25480                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25481         }
25482         if (flags & NDR_IN) {
25483                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25484                 ndr->depth++;
25485                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25486                 ndr->depth++;
25487                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25488                 ndr->depth--;
25489                 ndr->depth--;
25490         }
25491         if (flags & NDR_OUT) {
25492                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25493                 ndr->depth++;
25494                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25495                 ndr->depth++;
25496                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25497                 ndr->depth--;
25498                 ndr_print_WERROR(ndr, "result", r->out.result);
25499                 ndr->depth--;
25500         }
25501         ndr->depth--;
25502 }
25503
25504 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25505 {
25506         if (flags & NDR_IN) {
25507         }
25508         if (flags & NDR_OUT) {
25509                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25510         }
25511         return NDR_ERR_SUCCESS;
25512 }
25513
25514 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25515 {
25516         if (flags & NDR_IN) {
25517         }
25518         if (flags & NDR_OUT) {
25519                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25520         }
25521         return NDR_ERR_SUCCESS;
25522 }
25523
25524 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25525 {
25526         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25527         ndr->depth++;
25528         if (flags & NDR_SET_VALUES) {
25529                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25530         }
25531         if (flags & NDR_IN) {
25532                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25533                 ndr->depth++;
25534                 ndr->depth--;
25535         }
25536         if (flags & NDR_OUT) {
25537                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25538                 ndr->depth++;
25539                 ndr_print_WERROR(ndr, "result", r->out.result);
25540                 ndr->depth--;
25541         }
25542         ndr->depth--;
25543 }
25544
25545 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25546 {
25547         if (flags & NDR_IN) {
25548         }
25549         if (flags & NDR_OUT) {
25550                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25551         }
25552         return NDR_ERR_SUCCESS;
25553 }
25554
25555 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25556 {
25557         if (flags & NDR_IN) {
25558         }
25559         if (flags & NDR_OUT) {
25560                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25561         }
25562         return NDR_ERR_SUCCESS;
25563 }
25564
25565 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25566 {
25567         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25568         ndr->depth++;
25569         if (flags & NDR_SET_VALUES) {
25570                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25571         }
25572         if (flags & NDR_IN) {
25573                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25574                 ndr->depth++;
25575                 ndr->depth--;
25576         }
25577         if (flags & NDR_OUT) {
25578                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25579                 ndr->depth++;
25580                 ndr_print_WERROR(ndr, "result", r->out.result);
25581                 ndr->depth--;
25582         }
25583         ndr->depth--;
25584 }
25585
25586 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25587 {
25588         if (flags & NDR_IN) {
25589         }
25590         if (flags & NDR_OUT) {
25591                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25592         }
25593         return NDR_ERR_SUCCESS;
25594 }
25595
25596 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25597 {
25598         if (flags & NDR_IN) {
25599         }
25600         if (flags & NDR_OUT) {
25601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25602         }
25603         return NDR_ERR_SUCCESS;
25604 }
25605
25606 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25607 {
25608         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25609         ndr->depth++;
25610         if (flags & NDR_SET_VALUES) {
25611                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25612         }
25613         if (flags & NDR_IN) {
25614                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25615                 ndr->depth++;
25616                 ndr->depth--;
25617         }
25618         if (flags & NDR_OUT) {
25619                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25620                 ndr->depth++;
25621                 ndr_print_WERROR(ndr, "result", r->out.result);
25622                 ndr->depth--;
25623         }
25624         ndr->depth--;
25625 }
25626
25627 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25628 {
25629         if (flags & NDR_IN) {
25630         }
25631         if (flags & NDR_OUT) {
25632                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25633         }
25634         return NDR_ERR_SUCCESS;
25635 }
25636
25637 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25638 {
25639         if (flags & NDR_IN) {
25640         }
25641         if (flags & NDR_OUT) {
25642                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25643         }
25644         return NDR_ERR_SUCCESS;
25645 }
25646
25647 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25648 {
25649         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25650         ndr->depth++;
25651         if (flags & NDR_SET_VALUES) {
25652                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25653         }
25654         if (flags & NDR_IN) {
25655                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25656                 ndr->depth++;
25657                 ndr->depth--;
25658         }
25659         if (flags & NDR_OUT) {
25660                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25661                 ndr->depth++;
25662                 ndr_print_WERROR(ndr, "result", r->out.result);
25663                 ndr->depth--;
25664         }
25665         ndr->depth--;
25666 }
25667
25668 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25669 {
25670         if (flags & NDR_IN) {
25671         }
25672         if (flags & NDR_OUT) {
25673                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25674         }
25675         return NDR_ERR_SUCCESS;
25676 }
25677
25678 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25679 {
25680         if (flags & NDR_IN) {
25681         }
25682         if (flags & NDR_OUT) {
25683                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25684         }
25685         return NDR_ERR_SUCCESS;
25686 }
25687
25688 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25689 {
25690         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25691         ndr->depth++;
25692         if (flags & NDR_SET_VALUES) {
25693                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25694         }
25695         if (flags & NDR_IN) {
25696                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25697                 ndr->depth++;
25698                 ndr->depth--;
25699         }
25700         if (flags & NDR_OUT) {
25701                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25702                 ndr->depth++;
25703                 ndr_print_WERROR(ndr, "result", r->out.result);
25704                 ndr->depth--;
25705         }
25706         ndr->depth--;
25707 }
25708
25709 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25710 {
25711         if (flags & NDR_IN) {
25712         }
25713         if (flags & NDR_OUT) {
25714                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25715         }
25716         return NDR_ERR_SUCCESS;
25717 }
25718
25719 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25720 {
25721         if (flags & NDR_IN) {
25722         }
25723         if (flags & NDR_OUT) {
25724                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25725         }
25726         return NDR_ERR_SUCCESS;
25727 }
25728
25729 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25730 {
25731         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25732         ndr->depth++;
25733         if (flags & NDR_SET_VALUES) {
25734                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25735         }
25736         if (flags & NDR_IN) {
25737                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25738                 ndr->depth++;
25739                 ndr->depth--;
25740         }
25741         if (flags & NDR_OUT) {
25742                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25743                 ndr->depth++;
25744                 ndr_print_WERROR(ndr, "result", r->out.result);
25745                 ndr->depth--;
25746         }
25747         ndr->depth--;
25748 }
25749
25750 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25751 {
25752         if (flags & NDR_IN) {
25753         }
25754         if (flags & NDR_OUT) {
25755                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25756         }
25757         return NDR_ERR_SUCCESS;
25758 }
25759
25760 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25761 {
25762         if (flags & NDR_IN) {
25763         }
25764         if (flags & NDR_OUT) {
25765                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25766         }
25767         return NDR_ERR_SUCCESS;
25768 }
25769
25770 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25771 {
25772         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25773         ndr->depth++;
25774         if (flags & NDR_SET_VALUES) {
25775                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25776         }
25777         if (flags & NDR_IN) {
25778                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25779                 ndr->depth++;
25780                 ndr->depth--;
25781         }
25782         if (flags & NDR_OUT) {
25783                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25784                 ndr->depth++;
25785                 ndr_print_WERROR(ndr, "result", r->out.result);
25786                 ndr->depth--;
25787         }
25788         ndr->depth--;
25789 }
25790
25791 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25792 {
25793         if (flags & NDR_IN) {
25794         }
25795         if (flags & NDR_OUT) {
25796                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25797         }
25798         return NDR_ERR_SUCCESS;
25799 }
25800
25801 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25802 {
25803         if (flags & NDR_IN) {
25804         }
25805         if (flags & NDR_OUT) {
25806                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25807         }
25808         return NDR_ERR_SUCCESS;
25809 }
25810
25811 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25812 {
25813         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25814         ndr->depth++;
25815         if (flags & NDR_SET_VALUES) {
25816                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25817         }
25818         if (flags & NDR_IN) {
25819                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25820                 ndr->depth++;
25821                 ndr->depth--;
25822         }
25823         if (flags & NDR_OUT) {
25824                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25825                 ndr->depth++;
25826                 ndr_print_WERROR(ndr, "result", r->out.result);
25827                 ndr->depth--;
25828         }
25829         ndr->depth--;
25830 }
25831
25832 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25833 {
25834         if (flags & NDR_IN) {
25835                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25836                 if (r->in.servername) {
25837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25840                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25841                 }
25842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25843                 if (r->in.print_processor_name) {
25844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25847                         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));
25848                 }
25849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25851                 if (r->in.buffer) {
25852                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25853                 }
25854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25855         }
25856         if (flags & NDR_OUT) {
25857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25858                 if (r->out.info) {
25859                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25860                 }
25861                 if (r->out.needed == NULL) {
25862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25863                 }
25864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25865                 if (r->out.count == NULL) {
25866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25867                 }
25868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25869                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25870         }
25871         return NDR_ERR_SUCCESS;
25872 }
25873
25874 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25875 {
25876         uint32_t _ptr_servername;
25877         uint32_t _ptr_print_processor_name;
25878         uint32_t _ptr_buffer;
25879         uint32_t _ptr_info;
25880         TALLOC_CTX *_mem_save_servername_0;
25881         TALLOC_CTX *_mem_save_print_processor_name_0;
25882         TALLOC_CTX *_mem_save_buffer_0;
25883         TALLOC_CTX *_mem_save_info_0;
25884         TALLOC_CTX *_mem_save_needed_0;
25885         TALLOC_CTX *_mem_save_count_0;
25886         if (flags & NDR_IN) {
25887                 ZERO_STRUCT(r->out);
25888
25889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25890                 if (_ptr_servername) {
25891                         NDR_PULL_ALLOC(ndr, r->in.servername);
25892                 } else {
25893                         r->in.servername = NULL;
25894                 }
25895                 if (r->in.servername) {
25896                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25897                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25898                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25899                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25900                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25901                                 return 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));
25902                         }
25903                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25904                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25906                 }
25907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25908                 if (_ptr_print_processor_name) {
25909                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25910                 } else {
25911                         r->in.print_processor_name = NULL;
25912                 }
25913                 if (r->in.print_processor_name) {
25914                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25915                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25916                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25917                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25918                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25919                                 return 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));
25920                         }
25921                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25922                         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));
25923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25924                 }
25925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25927                 if (_ptr_buffer) {
25928                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25929                 } else {
25930                         r->in.buffer = NULL;
25931                 }
25932                 if (r->in.buffer) {
25933                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25934                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25935                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25937                 }
25938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25939                 NDR_PULL_ALLOC(ndr, r->out.needed);
25940                 ZERO_STRUCTP(r->out.needed);
25941                 NDR_PULL_ALLOC(ndr, r->out.count);
25942                 ZERO_STRUCTP(r->out.count);
25943         }
25944         if (flags & NDR_OUT) {
25945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25946                 if (_ptr_info) {
25947                         NDR_PULL_ALLOC(ndr, r->out.info);
25948                 } else {
25949                         r->out.info = NULL;
25950                 }
25951                 if (r->out.info) {
25952                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25953                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25954                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25956                 }
25957                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25958                         NDR_PULL_ALLOC(ndr, r->out.needed);
25959                 }
25960                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25961                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25963                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25965                         NDR_PULL_ALLOC(ndr, r->out.count);
25966                 }
25967                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25968                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25971                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25972         }
25973         return NDR_ERR_SUCCESS;
25974 }
25975
25976 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25977 {
25978         uint32_t cntr_info_0;
25979         if (flags & NDR_IN) {
25980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25982         }
25983         if (flags & NDR_OUT) {
25984                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25985                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25986                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25987                 }
25988                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25989                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25990                 }
25991         }
25992         return NDR_ERR_SUCCESS;
25993 }
25994
25995 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25996 {
25997         uint32_t cntr_info_0;
25998         TALLOC_CTX *_mem_save_info_0;
25999         if (flags & NDR_IN) {
26000                 ZERO_STRUCT(r->out);
26001
26002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26004         }
26005         if (flags & NDR_OUT) {
26006                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26007                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26008                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26009                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26010                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26011                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26012                 }
26013                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26014                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26015                 }
26016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26017         }
26018         return NDR_ERR_SUCCESS;
26019 }
26020
26021 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
26022 {
26023         uint32_t cntr_info_2;
26024         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
26025         ndr->depth++;
26026         if (flags & NDR_SET_VALUES) {
26027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26028         }
26029         if (flags & NDR_IN) {
26030                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
26031                 ndr->depth++;
26032                 ndr_print_ptr(ndr, "servername", r->in.servername);
26033                 ndr->depth++;
26034                 if (r->in.servername) {
26035                         ndr_print_string(ndr, "servername", r->in.servername);
26036                 }
26037                 ndr->depth--;
26038                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
26039                 ndr->depth++;
26040                 if (r->in.print_processor_name) {
26041                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
26042                 }
26043                 ndr->depth--;
26044                 ndr_print_uint32(ndr, "level", r->in.level);
26045                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26046                 ndr->depth++;
26047                 if (r->in.buffer) {
26048                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26049                 }
26050                 ndr->depth--;
26051                 ndr_print_uint32(ndr, "offered", r->in.offered);
26052                 ndr->depth--;
26053         }
26054         if (flags & NDR_OUT) {
26055                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
26056                 ndr->depth++;
26057                 ndr_print_ptr(ndr, "count", r->out.count);
26058                 ndr->depth++;
26059                 ndr_print_uint32(ndr, "count", *r->out.count);
26060                 ndr->depth--;
26061                 ndr_print_ptr(ndr, "info", r->out.info);
26062                 ndr->depth++;
26063                 ndr_print_ptr(ndr, "info", *r->out.info);
26064                 ndr->depth++;
26065                 if (*r->out.info) {
26066                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26067                         ndr->depth++;
26068                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26069                                 char *idx_2=NULL;
26070                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26071                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
26072                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
26073                                         free(idx_2);
26074                                 }
26075                         }
26076                         ndr->depth--;
26077                 }
26078                 ndr->depth--;
26079                 ndr->depth--;
26080                 ndr_print_ptr(ndr, "needed", r->out.needed);
26081                 ndr->depth++;
26082                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26083                 ndr->depth--;
26084                 ndr_print_WERROR(ndr, "result", r->out.result);
26085                 ndr->depth--;
26086         }
26087         ndr->depth--;
26088 }
26089
26090 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
26091 {
26092         if (flags & NDR_IN) {
26093                 if (r->in.handle == NULL) {
26094                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26095                 }
26096                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
26098                 if (r->in.data_type) {
26099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26102                         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));
26103                 }
26104                 if (r->in.devmode_ctr == NULL) {
26105                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26106                 }
26107                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26108         }
26109         if (flags & NDR_OUT) {
26110                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26111         }
26112         return NDR_ERR_SUCCESS;
26113 }
26114
26115 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
26116 {
26117         uint32_t _ptr_data_type;
26118         TALLOC_CTX *_mem_save_handle_0;
26119         TALLOC_CTX *_mem_save_data_type_0;
26120         TALLOC_CTX *_mem_save_devmode_ctr_0;
26121         if (flags & NDR_IN) {
26122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26123                         NDR_PULL_ALLOC(ndr, r->in.handle);
26124                 }
26125                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26126                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26127                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
26130                 if (_ptr_data_type) {
26131                         NDR_PULL_ALLOC(ndr, r->in.data_type);
26132                 } else {
26133                         r->in.data_type = NULL;
26134                 }
26135                 if (r->in.data_type) {
26136                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26137                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
26138                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
26139                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
26140                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
26141                                 return 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));
26142                         }
26143                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
26144                         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));
26145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
26146                 }
26147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26148                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26149                 }
26150                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26151                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26152                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26154         }
26155         if (flags & NDR_OUT) {
26156                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26157         }
26158         return NDR_ERR_SUCCESS;
26159 }
26160
26161 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
26162 {
26163         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
26164         ndr->depth++;
26165         if (flags & NDR_SET_VALUES) {
26166                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26167         }
26168         if (flags & NDR_IN) {
26169                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
26170                 ndr->depth++;
26171                 ndr_print_ptr(ndr, "handle", r->in.handle);
26172                 ndr->depth++;
26173                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26174                 ndr->depth--;
26175                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
26176                 ndr->depth++;
26177                 if (r->in.data_type) {
26178                         ndr_print_string(ndr, "data_type", r->in.data_type);
26179                 }
26180                 ndr->depth--;
26181                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26182                 ndr->depth++;
26183                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26184                 ndr->depth--;
26185                 ndr->depth--;
26186         }
26187         if (flags & NDR_OUT) {
26188                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
26189                 ndr->depth++;
26190                 ndr_print_WERROR(ndr, "result", r->out.result);
26191                 ndr->depth--;
26192         }
26193         ndr->depth--;
26194 }
26195
26196 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
26197 {
26198         if (flags & NDR_IN) {
26199                 if (r->in.handle == NULL) {
26200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26201                 }
26202                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
26204                 if (r->in.architecture) {
26205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26208                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26209                 }
26210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26212                 if (r->in.buffer) {
26213                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26214                 }
26215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
26217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
26218         }
26219         if (flags & NDR_OUT) {
26220                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26221                 if (r->out.info) {
26222                         {
26223                                 struct ndr_push *_ndr_info;
26224                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26225                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
26226                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26227                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26228                         }
26229                 }
26230                 if (r->out.needed == NULL) {
26231                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26232                 }
26233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26234                 if (r->out.server_major_version == NULL) {
26235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26236                 }
26237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
26238                 if (r->out.server_minor_version == NULL) {
26239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26240                 }
26241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
26242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26243         }
26244         return NDR_ERR_SUCCESS;
26245 }
26246
26247 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
26248 {
26249         uint32_t _ptr_architecture;
26250         uint32_t _ptr_buffer;
26251         uint32_t _ptr_info;
26252         TALLOC_CTX *_mem_save_handle_0;
26253         TALLOC_CTX *_mem_save_architecture_0;
26254         TALLOC_CTX *_mem_save_buffer_0;
26255         TALLOC_CTX *_mem_save_info_0;
26256         TALLOC_CTX *_mem_save_needed_0;
26257         TALLOC_CTX *_mem_save_server_major_version_0;
26258         TALLOC_CTX *_mem_save_server_minor_version_0;
26259         if (flags & NDR_IN) {
26260                 ZERO_STRUCT(r->out);
26261
26262                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26263                         NDR_PULL_ALLOC(ndr, r->in.handle);
26264                 }
26265                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26266                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26267                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26268                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
26270                 if (_ptr_architecture) {
26271                         NDR_PULL_ALLOC(ndr, r->in.architecture);
26272                 } else {
26273                         r->in.architecture = NULL;
26274                 }
26275                 if (r->in.architecture) {
26276                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
26277                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
26278                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26279                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26280                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26281                                 return 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));
26282                         }
26283                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26284                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
26286                 }
26287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26289                 if (_ptr_buffer) {
26290                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26291                 } else {
26292                         r->in.buffer = NULL;
26293                 }
26294                 if (r->in.buffer) {
26295                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26296                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26297                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26299                 }
26300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
26302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
26303                 NDR_PULL_ALLOC(ndr, r->out.needed);
26304                 ZERO_STRUCTP(r->out.needed);
26305                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26306                 ZERO_STRUCTP(r->out.server_major_version);
26307                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26308                 ZERO_STRUCTP(r->out.server_minor_version);
26309         }
26310         if (flags & NDR_OUT) {
26311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26312                 if (_ptr_info) {
26313                         NDR_PULL_ALLOC(ndr, r->out.info);
26314                 } else {
26315                         r->out.info = NULL;
26316                 }
26317                 if (r->out.info) {
26318                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26319                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26320                         {
26321                                 struct ndr_pull *_ndr_info;
26322                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26323                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
26324                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26325                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26326                         }
26327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26328                 }
26329                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26330                         NDR_PULL_ALLOC(ndr, r->out.needed);
26331                 }
26332                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26333                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26337                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26338                 }
26339                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26340                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
26341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
26342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
26343                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26344                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26345                 }
26346                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26347                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26351         }
26352         return NDR_ERR_SUCCESS;
26353 }
26354
26355 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26356 {
26357         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26358         ndr->depth++;
26359         if (flags & NDR_SET_VALUES) {
26360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26361         }
26362         if (flags & NDR_IN) {
26363                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26364                 ndr->depth++;
26365                 ndr_print_ptr(ndr, "handle", r->in.handle);
26366                 ndr->depth++;
26367                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26368                 ndr->depth--;
26369                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26370                 ndr->depth++;
26371                 if (r->in.architecture) {
26372                         ndr_print_string(ndr, "architecture", r->in.architecture);
26373                 }
26374                 ndr->depth--;
26375                 ndr_print_uint32(ndr, "level", r->in.level);
26376                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26377                 ndr->depth++;
26378                 if (r->in.buffer) {
26379                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26380                 }
26381                 ndr->depth--;
26382                 ndr_print_uint32(ndr, "offered", r->in.offered);
26383                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26384                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26385                 ndr->depth--;
26386         }
26387         if (flags & NDR_OUT) {
26388                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26389                 ndr->depth++;
26390                 ndr_print_ptr(ndr, "info", r->out.info);
26391                 ndr->depth++;
26392                 if (r->out.info) {
26393                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26394                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26395                 }
26396                 ndr->depth--;
26397                 ndr_print_ptr(ndr, "needed", r->out.needed);
26398                 ndr->depth++;
26399                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26400                 ndr->depth--;
26401                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26402                 ndr->depth++;
26403                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26404                 ndr->depth--;
26405                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26406                 ndr->depth++;
26407                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26408                 ndr->depth--;
26409                 ndr_print_WERROR(ndr, "result", r->out.result);
26410                 ndr->depth--;
26411         }
26412         ndr->depth--;
26413 }
26414
26415 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26416 {
26417         if (flags & NDR_IN) {
26418         }
26419         if (flags & NDR_OUT) {
26420                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26421         }
26422         return NDR_ERR_SUCCESS;
26423 }
26424
26425 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26426 {
26427         if (flags & NDR_IN) {
26428         }
26429         if (flags & NDR_OUT) {
26430                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26431         }
26432         return NDR_ERR_SUCCESS;
26433 }
26434
26435 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26436 {
26437         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26438         ndr->depth++;
26439         if (flags & NDR_SET_VALUES) {
26440                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26441         }
26442         if (flags & NDR_IN) {
26443                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26444                 ndr->depth++;
26445                 ndr->depth--;
26446         }
26447         if (flags & NDR_OUT) {
26448                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26449                 ndr->depth++;
26450                 ndr_print_WERROR(ndr, "result", r->out.result);
26451                 ndr->depth--;
26452         }
26453         ndr->depth--;
26454 }
26455
26456 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26457 {
26458         if (flags & NDR_IN) {
26459         }
26460         if (flags & NDR_OUT) {
26461                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26462         }
26463         return NDR_ERR_SUCCESS;
26464 }
26465
26466 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26467 {
26468         if (flags & NDR_IN) {
26469         }
26470         if (flags & NDR_OUT) {
26471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26472         }
26473         return NDR_ERR_SUCCESS;
26474 }
26475
26476 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26477 {
26478         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26479         ndr->depth++;
26480         if (flags & NDR_SET_VALUES) {
26481                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26482         }
26483         if (flags & NDR_IN) {
26484                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26485                 ndr->depth++;
26486                 ndr->depth--;
26487         }
26488         if (flags & NDR_OUT) {
26489                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26490                 ndr->depth++;
26491                 ndr_print_WERROR(ndr, "result", r->out.result);
26492                 ndr->depth--;
26493         }
26494         ndr->depth--;
26495 }
26496
26497 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26498 {
26499         if (flags & NDR_IN) {
26500                 if (r->in.handle == NULL) {
26501                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26502                 }
26503                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26504         }
26505         if (flags & NDR_OUT) {
26506                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26507         }
26508         return NDR_ERR_SUCCESS;
26509 }
26510
26511 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26512 {
26513         TALLOC_CTX *_mem_save_handle_0;
26514         if (flags & NDR_IN) {
26515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26516                         NDR_PULL_ALLOC(ndr, r->in.handle);
26517                 }
26518                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26519                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26520                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26522         }
26523         if (flags & NDR_OUT) {
26524                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26525         }
26526         return NDR_ERR_SUCCESS;
26527 }
26528
26529 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26530 {
26531         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26532         ndr->depth++;
26533         if (flags & NDR_SET_VALUES) {
26534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26535         }
26536         if (flags & NDR_IN) {
26537                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26538                 ndr->depth++;
26539                 ndr_print_ptr(ndr, "handle", r->in.handle);
26540                 ndr->depth++;
26541                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26542                 ndr->depth--;
26543                 ndr->depth--;
26544         }
26545         if (flags & NDR_OUT) {
26546                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26547                 ndr->depth++;
26548                 ndr_print_WERROR(ndr, "result", r->out.result);
26549                 ndr->depth--;
26550         }
26551         ndr->depth--;
26552 }
26553
26554 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26555 {
26556         if (flags & NDR_IN) {
26557         }
26558         if (flags & NDR_OUT) {
26559                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26560         }
26561         return NDR_ERR_SUCCESS;
26562 }
26563
26564 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26565 {
26566         if (flags & NDR_IN) {
26567         }
26568         if (flags & NDR_OUT) {
26569                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26570         }
26571         return NDR_ERR_SUCCESS;
26572 }
26573
26574 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26575 {
26576         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26577         ndr->depth++;
26578         if (flags & NDR_SET_VALUES) {
26579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26580         }
26581         if (flags & NDR_IN) {
26582                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26583                 ndr->depth++;
26584                 ndr->depth--;
26585         }
26586         if (flags & NDR_OUT) {
26587                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26588                 ndr->depth++;
26589                 ndr_print_WERROR(ndr, "result", r->out.result);
26590                 ndr->depth--;
26591         }
26592         ndr->depth--;
26593 }
26594
26595 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26596 {
26597         if (flags & NDR_IN) {
26598                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26599                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26600                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26601                 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));
26602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26603                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26606                 if (r->in.buffer) {
26607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26608                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26609                 }
26610         }
26611         if (flags & NDR_OUT) {
26612                 if (r->out.handle == NULL) {
26613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26614                 }
26615                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26616                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26617         }
26618         return NDR_ERR_SUCCESS;
26619 }
26620
26621 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26622 {
26623         uint32_t _ptr_buffer;
26624         TALLOC_CTX *_mem_save_buffer_0;
26625         TALLOC_CTX *_mem_save_handle_0;
26626         if (flags & NDR_IN) {
26627                 ZERO_STRUCT(r->out);
26628
26629                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26630                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26631                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26632                         return 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));
26633                 }
26634                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26635                 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));
26636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26637                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26639                 if (r->in.bufsize > 512) {
26640                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26641                 }
26642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26643                 if (_ptr_buffer) {
26644                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26645                 } else {
26646                         r->in.buffer = NULL;
26647                 }
26648                 if (r->in.buffer) {
26649                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26650                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26652                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26653                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26655                 }
26656                 NDR_PULL_ALLOC(ndr, r->out.handle);
26657                 ZERO_STRUCTP(r->out.handle);
26658                 if (r->in.buffer) {
26659                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26660                 }
26661         }
26662         if (flags & NDR_OUT) {
26663                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26664                         NDR_PULL_ALLOC(ndr, r->out.handle);
26665                 }
26666                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26667                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26668                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26669                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26670                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26671         }
26672         return NDR_ERR_SUCCESS;
26673 }
26674
26675 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26676 {
26677         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26678         ndr->depth++;
26679         if (flags & NDR_SET_VALUES) {
26680                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26681         }
26682         if (flags & NDR_IN) {
26683                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26684                 ndr->depth++;
26685                 ndr_print_string(ndr, "server_name", r->in.server_name);
26686                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26687                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26688                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26689                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26690                 ndr->depth++;
26691                 if (r->in.buffer) {
26692                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26693                 }
26694                 ndr->depth--;
26695                 ndr->depth--;
26696         }
26697         if (flags & NDR_OUT) {
26698                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26699                 ndr->depth++;
26700                 ndr_print_ptr(ndr, "handle", r->out.handle);
26701                 ndr->depth++;
26702                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26703                 ndr->depth--;
26704                 ndr_print_WERROR(ndr, "result", r->out.result);
26705                 ndr->depth--;
26706         }
26707         ndr->depth--;
26708 }
26709
26710 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26711 {
26712         if (flags & NDR_IN) {
26713                 if (r->in.handle == NULL) {
26714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26715                 }
26716                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26717                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26720                 if (r->in.buffer) {
26721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26722                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26723                 }
26724         }
26725         if (flags & NDR_OUT) {
26726                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26727         }
26728         return NDR_ERR_SUCCESS;
26729 }
26730
26731 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26732 {
26733         uint32_t _ptr_buffer;
26734         TALLOC_CTX *_mem_save_handle_0;
26735         TALLOC_CTX *_mem_save_buffer_0;
26736         if (flags & NDR_IN) {
26737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26738                         NDR_PULL_ALLOC(ndr, r->in.handle);
26739                 }
26740                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26741                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26742                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26744                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26746                 if (r->in.bufsize > 512) {
26747                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26748                 }
26749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26750                 if (_ptr_buffer) {
26751                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26752                 } else {
26753                         r->in.buffer = NULL;
26754                 }
26755                 if (r->in.buffer) {
26756                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26757                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26758                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26759                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26760                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26762                 }
26763                 if (r->in.buffer) {
26764                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26765                 }
26766         }
26767         if (flags & NDR_OUT) {
26768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26769         }
26770         return NDR_ERR_SUCCESS;
26771 }
26772
26773 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26774 {
26775         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26776         ndr->depth++;
26777         if (flags & NDR_SET_VALUES) {
26778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26779         }
26780         if (flags & NDR_IN) {
26781                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26782                 ndr->depth++;
26783                 ndr_print_ptr(ndr, "handle", r->in.handle);
26784                 ndr->depth++;
26785                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26786                 ndr->depth--;
26787                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26788                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26789                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26790                 ndr->depth++;
26791                 if (r->in.buffer) {
26792                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26793                 }
26794                 ndr->depth--;
26795                 ndr->depth--;
26796         }
26797         if (flags & NDR_OUT) {
26798                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26799                 ndr->depth++;
26800                 ndr_print_WERROR(ndr, "result", r->out.result);
26801                 ndr->depth--;
26802         }
26803         ndr->depth--;
26804 }
26805
26806 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26807 {
26808         if (flags & NDR_IN) {
26809                 if (r->in.handle == NULL) {
26810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26811                 }
26812                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26813         }
26814         if (flags & NDR_OUT) {
26815                 if (r->out.handle == NULL) {
26816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26817                 }
26818                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26819                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26820         }
26821         return NDR_ERR_SUCCESS;
26822 }
26823
26824 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26825 {
26826         TALLOC_CTX *_mem_save_handle_0;
26827         if (flags & NDR_IN) {
26828                 ZERO_STRUCT(r->out);
26829
26830                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26831                         NDR_PULL_ALLOC(ndr, r->in.handle);
26832                 }
26833                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26834                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26835                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26836                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26837                 NDR_PULL_ALLOC(ndr, r->out.handle);
26838                 *r->out.handle = *r->in.handle;
26839         }
26840         if (flags & NDR_OUT) {
26841                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26842                         NDR_PULL_ALLOC(ndr, r->out.handle);
26843                 }
26844                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26845                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26846                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26849         }
26850         return NDR_ERR_SUCCESS;
26851 }
26852
26853 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26854 {
26855         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26856         ndr->depth++;
26857         if (flags & NDR_SET_VALUES) {
26858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26859         }
26860         if (flags & NDR_IN) {
26861                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26862                 ndr->depth++;
26863                 ndr_print_ptr(ndr, "handle", r->in.handle);
26864                 ndr->depth++;
26865                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26866                 ndr->depth--;
26867                 ndr->depth--;
26868         }
26869         if (flags & NDR_OUT) {
26870                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26871                 ndr->depth++;
26872                 ndr_print_ptr(ndr, "handle", r->out.handle);
26873                 ndr->depth++;
26874                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26875                 ndr->depth--;
26876                 ndr_print_WERROR(ndr, "result", r->out.result);
26877                 ndr->depth--;
26878         }
26879         ndr->depth--;
26880 }
26881
26882 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26883 {
26884         if (flags & NDR_IN) {
26885         }
26886         if (flags & NDR_OUT) {
26887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26888         }
26889         return NDR_ERR_SUCCESS;
26890 }
26891
26892 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26893 {
26894         if (flags & NDR_IN) {
26895         }
26896         if (flags & NDR_OUT) {
26897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26898         }
26899         return NDR_ERR_SUCCESS;
26900 }
26901
26902 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26903 {
26904         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
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_AddPortEx");
26911                 ndr->depth++;
26912                 ndr->depth--;
26913         }
26914         if (flags & NDR_OUT) {
26915                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26916                 ndr->depth++;
26917                 ndr_print_WERROR(ndr, "result", r->out.result);
26918                 ndr->depth--;
26919         }
26920         ndr->depth--;
26921 }
26922
26923 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26924 {
26925         if (flags & NDR_IN) {
26926         }
26927         if (flags & NDR_OUT) {
26928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26929         }
26930         return NDR_ERR_SUCCESS;
26931 }
26932
26933 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26934 {
26935         if (flags & NDR_IN) {
26936         }
26937         if (flags & NDR_OUT) {
26938                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26939         }
26940         return NDR_ERR_SUCCESS;
26941 }
26942
26943 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26944 {
26945         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26946         ndr->depth++;
26947         if (flags & NDR_SET_VALUES) {
26948                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26949         }
26950         if (flags & NDR_IN) {
26951                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26952                 ndr->depth++;
26953                 ndr->depth--;
26954         }
26955         if (flags & NDR_OUT) {
26956                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26957                 ndr->depth++;
26958                 ndr_print_WERROR(ndr, "result", r->out.result);
26959                 ndr->depth--;
26960         }
26961         ndr->depth--;
26962 }
26963
26964 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26965 {
26966         if (flags & NDR_IN) {
26967         }
26968         if (flags & NDR_OUT) {
26969                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26970         }
26971         return NDR_ERR_SUCCESS;
26972 }
26973
26974 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26975 {
26976         if (flags & NDR_IN) {
26977         }
26978         if (flags & NDR_OUT) {
26979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26980         }
26981         return NDR_ERR_SUCCESS;
26982 }
26983
26984 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26985 {
26986         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26987         ndr->depth++;
26988         if (flags & NDR_SET_VALUES) {
26989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26990         }
26991         if (flags & NDR_IN) {
26992                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26993                 ndr->depth++;
26994                 ndr->depth--;
26995         }
26996         if (flags & NDR_OUT) {
26997                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26998                 ndr->depth++;
26999                 ndr_print_WERROR(ndr, "result", r->out.result);
27000                 ndr->depth--;
27001         }
27002         ndr->depth--;
27003 }
27004
27005 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
27006 {
27007         if (flags & NDR_IN) {
27008         }
27009         if (flags & NDR_OUT) {
27010                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27011         }
27012         return NDR_ERR_SUCCESS;
27013 }
27014
27015 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
27016 {
27017         if (flags & NDR_IN) {
27018         }
27019         if (flags & NDR_OUT) {
27020                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27021         }
27022         return NDR_ERR_SUCCESS;
27023 }
27024
27025 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
27026 {
27027         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
27028         ndr->depth++;
27029         if (flags & NDR_SET_VALUES) {
27030                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27031         }
27032         if (flags & NDR_IN) {
27033                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
27034                 ndr->depth++;
27035                 ndr->depth--;
27036         }
27037         if (flags & NDR_OUT) {
27038                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
27039                 ndr->depth++;
27040                 ndr_print_WERROR(ndr, "result", r->out.result);
27041                 ndr->depth--;
27042         }
27043         ndr->depth--;
27044 }
27045
27046 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27047 {
27048         if (flags & NDR_IN) {
27049                 if (r->in.handle == NULL) {
27050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27051                 }
27052                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27053                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
27055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
27056                 if (r->in.local_machine) {
27057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27058                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27059                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27060                         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));
27061                 }
27062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
27063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
27064                 if (r->in.notify_options) {
27065                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27066                 }
27067         }
27068         if (flags & NDR_OUT) {
27069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27070         }
27071         return NDR_ERR_SUCCESS;
27072 }
27073
27074 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27075 {
27076         uint32_t _ptr_local_machine;
27077         uint32_t _ptr_notify_options;
27078         TALLOC_CTX *_mem_save_handle_0;
27079         TALLOC_CTX *_mem_save_local_machine_0;
27080         TALLOC_CTX *_mem_save_notify_options_0;
27081         if (flags & NDR_IN) {
27082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27083                         NDR_PULL_ALLOC(ndr, r->in.handle);
27084                 }
27085                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27087                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27089                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
27091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
27092                 if (_ptr_local_machine) {
27093                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
27094                 } else {
27095                         r->in.local_machine = NULL;
27096                 }
27097                 if (r->in.local_machine) {
27098                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
27099                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
27100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
27101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
27102                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
27103                                 return 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));
27104                         }
27105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
27106                         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));
27107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
27108                 }
27109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
27110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
27111                 if (_ptr_notify_options) {
27112                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
27113                 } else {
27114                         r->in.notify_options = NULL;
27115                 }
27116                 if (r->in.notify_options) {
27117                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27118                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
27119                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
27121                 }
27122         }
27123         if (flags & NDR_OUT) {
27124                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27125         }
27126         return NDR_ERR_SUCCESS;
27127 }
27128
27129 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27130 {
27131         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27132         ndr->depth++;
27133         if (flags & NDR_SET_VALUES) {
27134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27135         }
27136         if (flags & NDR_IN) {
27137                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27138                 ndr->depth++;
27139                 ndr_print_ptr(ndr, "handle", r->in.handle);
27140                 ndr->depth++;
27141                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27142                 ndr->depth--;
27143                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27144                 ndr_print_uint32(ndr, "options", r->in.options);
27145                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
27146                 ndr->depth++;
27147                 if (r->in.local_machine) {
27148                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
27149                 }
27150                 ndr->depth--;
27151                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27152                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
27153                 ndr->depth++;
27154                 if (r->in.notify_options) {
27155                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
27156                 }
27157                 ndr->depth--;
27158                 ndr->depth--;
27159         }
27160         if (flags & NDR_OUT) {
27161                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27162                 ndr->depth++;
27163                 ndr_print_WERROR(ndr, "result", r->out.result);
27164                 ndr->depth--;
27165         }
27166         ndr->depth--;
27167 }
27168
27169 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27170 {
27171         if (flags & NDR_IN) {
27172                 if (r->in.handle == NULL) {
27173                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27174                 }
27175                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
27177                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
27179                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27180                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27181         }
27182         if (flags & NDR_OUT) {
27183                 if (r->out.reply_result == NULL) {
27184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27185                 }
27186                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
27187                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27188         }
27189         return NDR_ERR_SUCCESS;
27190 }
27191
27192 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
27193 {
27194         TALLOC_CTX *_mem_save_handle_0;
27195         TALLOC_CTX *_mem_save_reply_result_0;
27196         if (flags & NDR_IN) {
27197                 ZERO_STRUCT(r->out);
27198
27199                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27200                         NDR_PULL_ALLOC(ndr, r->in.handle);
27201                 }
27202                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27203                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27204                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
27207                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
27209                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27210                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27211                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
27212                 ZERO_STRUCTP(r->out.reply_result);
27213         }
27214         if (flags & NDR_OUT) {
27215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27216                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
27217                 }
27218                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
27219                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
27220                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
27221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
27222                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27223         }
27224         return NDR_ERR_SUCCESS;
27225 }
27226
27227 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27228 {
27229         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
27230         ndr->depth++;
27231         if (flags & NDR_SET_VALUES) {
27232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27233         }
27234         if (flags & NDR_IN) {
27235                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
27236                 ndr->depth++;
27237                 ndr_print_ptr(ndr, "handle", r->in.handle);
27238                 ndr->depth++;
27239                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27240                 ndr->depth--;
27241                 ndr_print_uint32(ndr, "color", r->in.color);
27242                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27243                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
27244                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
27245                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
27246                 ndr->depth--;
27247         }
27248         if (flags & NDR_OUT) {
27249                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
27250                 ndr->depth++;
27251                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
27252                 ndr->depth++;
27253                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
27254                 ndr->depth--;
27255                 ndr_print_WERROR(ndr, "result", r->out.result);
27256                 ndr->depth--;
27257         }
27258         ndr->depth--;
27259 }
27260
27261 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27262 {
27263         if (flags & NDR_IN) {
27264                 if (r->in.handle == NULL) {
27265                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27266                 }
27267                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
27269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
27270                 if (r->in.options) {
27271                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27272                 }
27273         }
27274         if (flags & NDR_OUT) {
27275                 if (r->out.info == NULL) {
27276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27277                 }
27278                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
27279                 if (*r->out.info) {
27280                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27281                 }
27282                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27283         }
27284         return NDR_ERR_SUCCESS;
27285 }
27286
27287 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
27288 {
27289         uint32_t _ptr_options;
27290         uint32_t _ptr_info;
27291         TALLOC_CTX *_mem_save_handle_0;
27292         TALLOC_CTX *_mem_save_options_0;
27293         TALLOC_CTX *_mem_save_info_0;
27294         TALLOC_CTX *_mem_save_info_1;
27295         if (flags & NDR_IN) {
27296                 ZERO_STRUCT(r->out);
27297
27298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27299                         NDR_PULL_ALLOC(ndr, r->in.handle);
27300                 }
27301                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27303                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
27306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
27307                 if (_ptr_options) {
27308                         NDR_PULL_ALLOC(ndr, r->in.options);
27309                 } else {
27310                         r->in.options = NULL;
27311                 }
27312                 if (r->in.options) {
27313                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27314                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
27315                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
27317                 }
27318                 NDR_PULL_ALLOC(ndr, r->out.info);
27319                 ZERO_STRUCTP(r->out.info);
27320         }
27321         if (flags & NDR_OUT) {
27322                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27323                         NDR_PULL_ALLOC(ndr, r->out.info);
27324                 }
27325                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27326                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
27327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
27328                 if (_ptr_info) {
27329                         NDR_PULL_ALLOC(ndr, *r->out.info);
27330                 } else {
27331                         *r->out.info = NULL;
27332                 }
27333                 if (*r->out.info) {
27334                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
27335                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
27336                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
27338                 }
27339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
27340                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27341         }
27342         return NDR_ERR_SUCCESS;
27343 }
27344
27345 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27346 {
27347         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27348         ndr->depth++;
27349         if (flags & NDR_SET_VALUES) {
27350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27351         }
27352         if (flags & NDR_IN) {
27353                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27354                 ndr->depth++;
27355                 ndr_print_ptr(ndr, "handle", r->in.handle);
27356                 ndr->depth++;
27357                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27358                 ndr->depth--;
27359                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
27360                 ndr_print_ptr(ndr, "options", r->in.options);
27361                 ndr->depth++;
27362                 if (r->in.options) {
27363                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27364                 }
27365                 ndr->depth--;
27366                 ndr->depth--;
27367         }
27368         if (flags & NDR_OUT) {
27369                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27370                 ndr->depth++;
27371                 ndr_print_ptr(ndr, "info", r->out.info);
27372                 ndr->depth++;
27373                 ndr_print_ptr(ndr, "info", *r->out.info);
27374                 ndr->depth++;
27375                 if (*r->out.info) {
27376                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27377                 }
27378                 ndr->depth--;
27379                 ndr->depth--;
27380                 ndr_print_WERROR(ndr, "result", r->out.result);
27381                 ndr->depth--;
27382         }
27383         ndr->depth--;
27384 }
27385
27386 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27387 {
27388         if (flags & NDR_IN) {
27389         }
27390         if (flags & NDR_OUT) {
27391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27392         }
27393         return NDR_ERR_SUCCESS;
27394 }
27395
27396 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27397 {
27398         if (flags & NDR_IN) {
27399         }
27400         if (flags & NDR_OUT) {
27401                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27402         }
27403         return NDR_ERR_SUCCESS;
27404 }
27405
27406 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27407 {
27408         ndr_print_struct(ndr, name, "spoolss_44");
27409         ndr->depth++;
27410         if (flags & NDR_SET_VALUES) {
27411                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27412         }
27413         if (flags & NDR_IN) {
27414                 ndr_print_struct(ndr, "in", "spoolss_44");
27415                 ndr->depth++;
27416                 ndr->depth--;
27417         }
27418         if (flags & NDR_OUT) {
27419                 ndr_print_struct(ndr, "out", "spoolss_44");
27420                 ndr->depth++;
27421                 ndr_print_WERROR(ndr, "result", r->out.result);
27422                 ndr->depth--;
27423         }
27424         ndr->depth--;
27425 }
27426
27427 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27428 {
27429         if (flags & NDR_IN) {
27430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27431                 if (r->in.printername) {
27432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27436                 }
27437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27438                 if (r->in.datatype) {
27439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27442                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27443                 }
27444                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27445                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27447                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27448                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27449         }
27450         if (flags & NDR_OUT) {
27451                 if (r->out.handle == NULL) {
27452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27453                 }
27454                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27455                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27456         }
27457         return NDR_ERR_SUCCESS;
27458 }
27459
27460 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27461 {
27462         uint32_t _ptr_printername;
27463         uint32_t _ptr_datatype;
27464         TALLOC_CTX *_mem_save_printername_0;
27465         TALLOC_CTX *_mem_save_datatype_0;
27466         TALLOC_CTX *_mem_save_handle_0;
27467         if (flags & NDR_IN) {
27468                 ZERO_STRUCT(r->out);
27469
27470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27471                 if (_ptr_printername) {
27472                         NDR_PULL_ALLOC(ndr, r->in.printername);
27473                 } else {
27474                         r->in.printername = NULL;
27475                 }
27476                 if (r->in.printername) {
27477                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27478                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27479                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27480                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27481                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27482                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.printername), ndr_get_array_length(ndr, &r->in.printername));
27483                         }
27484                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27485                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27487                 }
27488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27489                 if (_ptr_datatype) {
27490                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27491                 } else {
27492                         r->in.datatype = NULL;
27493                 }
27494                 if (r->in.datatype) {
27495                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27496                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27499                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27500                                 return 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));
27501                         }
27502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27505                 }
27506                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27507                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27509                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27510                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27511                 NDR_PULL_ALLOC(ndr, r->out.handle);
27512                 ZERO_STRUCTP(r->out.handle);
27513         }
27514         if (flags & NDR_OUT) {
27515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27516                         NDR_PULL_ALLOC(ndr, r->out.handle);
27517                 }
27518                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27519                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27520                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27522                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27523         }
27524         return NDR_ERR_SUCCESS;
27525 }
27526
27527 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27528 {
27529         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27530         ndr->depth++;
27531         if (flags & NDR_SET_VALUES) {
27532                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27533         }
27534         if (flags & NDR_IN) {
27535                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27536                 ndr->depth++;
27537                 ndr_print_ptr(ndr, "printername", r->in.printername);
27538                 ndr->depth++;
27539                 if (r->in.printername) {
27540                         ndr_print_string(ndr, "printername", r->in.printername);
27541                 }
27542                 ndr->depth--;
27543                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27544                 ndr->depth++;
27545                 if (r->in.datatype) {
27546                         ndr_print_string(ndr, "datatype", r->in.datatype);
27547                 }
27548                 ndr->depth--;
27549                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27550                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27551                 ndr_print_uint32(ndr, "level", r->in.level);
27552                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27553                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27554                 ndr->depth--;
27555         }
27556         if (flags & NDR_OUT) {
27557                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27558                 ndr->depth++;
27559                 ndr_print_ptr(ndr, "handle", r->out.handle);
27560                 ndr->depth++;
27561                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27562                 ndr->depth--;
27563                 ndr_print_WERROR(ndr, "result", r->out.result);
27564                 ndr->depth--;
27565         }
27566         ndr->depth--;
27567 }
27568
27569 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27570 {
27571         if (flags & NDR_IN) {
27572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27573                 if (r->in.server) {
27574                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27575                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27576                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27577                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27578                 }
27579                 if (r->in.info_ctr == NULL) {
27580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27581                 }
27582                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27583                 if (r->in.devmode_ctr == NULL) {
27584                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27585                 }
27586                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27587                 if (r->in.secdesc_ctr == NULL) {
27588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27589                 }
27590                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27591                 if (r->in.userlevel_ctr == NULL) {
27592                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27593                 }
27594                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27595         }
27596         if (flags & NDR_OUT) {
27597                 if (r->out.handle == NULL) {
27598                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27599                 }
27600                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27601                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27602         }
27603         return NDR_ERR_SUCCESS;
27604 }
27605
27606 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27607 {
27608         uint32_t _ptr_server;
27609         TALLOC_CTX *_mem_save_server_0;
27610         TALLOC_CTX *_mem_save_info_ctr_0;
27611         TALLOC_CTX *_mem_save_devmode_ctr_0;
27612         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27613         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27614         TALLOC_CTX *_mem_save_handle_0;
27615         if (flags & NDR_IN) {
27616                 ZERO_STRUCT(r->out);
27617
27618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27619                 if (_ptr_server) {
27620                         NDR_PULL_ALLOC(ndr, r->in.server);
27621                 } else {
27622                         r->in.server = NULL;
27623                 }
27624                 if (r->in.server) {
27625                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27626                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27629                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27630                                 return 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));
27631                         }
27632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27635                 }
27636                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27637                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27638                 }
27639                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27640                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27641                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27644                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27645                 }
27646                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27647                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27648                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27650                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27651                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27652                 }
27653                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27654                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27655                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27656                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27657                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27658                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27659                 }
27660                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27661                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27662                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27663                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27664                 NDR_PULL_ALLOC(ndr, r->out.handle);
27665                 ZERO_STRUCTP(r->out.handle);
27666         }
27667         if (flags & NDR_OUT) {
27668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27669                         NDR_PULL_ALLOC(ndr, r->out.handle);
27670                 }
27671                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27672                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27673                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27675                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27676         }
27677         return NDR_ERR_SUCCESS;
27678 }
27679
27680 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27681 {
27682         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27683         ndr->depth++;
27684         if (flags & NDR_SET_VALUES) {
27685                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27686         }
27687         if (flags & NDR_IN) {
27688                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27689                 ndr->depth++;
27690                 ndr_print_ptr(ndr, "server", r->in.server);
27691                 ndr->depth++;
27692                 if (r->in.server) {
27693                         ndr_print_string(ndr, "server", r->in.server);
27694                 }
27695                 ndr->depth--;
27696                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27697                 ndr->depth++;
27698                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27699                 ndr->depth--;
27700                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27701                 ndr->depth++;
27702                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27703                 ndr->depth--;
27704                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27705                 ndr->depth++;
27706                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27707                 ndr->depth--;
27708                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27709                 ndr->depth++;
27710                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27711                 ndr->depth--;
27712                 ndr->depth--;
27713         }
27714         if (flags & NDR_OUT) {
27715                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27716                 ndr->depth++;
27717                 ndr_print_ptr(ndr, "handle", r->out.handle);
27718                 ndr->depth++;
27719                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27720                 ndr->depth--;
27721                 ndr_print_WERROR(ndr, "result", r->out.result);
27722                 ndr->depth--;
27723         }
27724         ndr->depth--;
27725 }
27726
27727 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27728 {
27729         if (flags & NDR_IN) {
27730         }
27731         if (flags & NDR_OUT) {
27732                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27733         }
27734         return NDR_ERR_SUCCESS;
27735 }
27736
27737 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27738 {
27739         if (flags & NDR_IN) {
27740         }
27741         if (flags & NDR_OUT) {
27742                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27743         }
27744         return NDR_ERR_SUCCESS;
27745 }
27746
27747 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27748 {
27749         ndr_print_struct(ndr, name, "spoolss_47");
27750         ndr->depth++;
27751         if (flags & NDR_SET_VALUES) {
27752                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27753         }
27754         if (flags & NDR_IN) {
27755                 ndr_print_struct(ndr, "in", "spoolss_47");
27756                 ndr->depth++;
27757                 ndr->depth--;
27758         }
27759         if (flags & NDR_OUT) {
27760                 ndr_print_struct(ndr, "out", "spoolss_47");
27761                 ndr->depth++;
27762                 ndr_print_WERROR(ndr, "result", r->out.result);
27763                 ndr->depth--;
27764         }
27765         ndr->depth--;
27766 }
27767
27768 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27769 {
27770         if (flags & NDR_IN) {
27771                 if (r->in.handle == NULL) {
27772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27773                 }
27774                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27778         }
27779         if (flags & NDR_OUT) {
27780                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27781                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27782                 if (r->out.value_needed == NULL) {
27783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27784                 }
27785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27786                 if (r->out.type == NULL) {
27787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27788                 }
27789                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27790                 {
27791                         uint32_t _flags_save_uint8 = ndr->flags;
27792                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27793                         if (r->out.data == NULL) {
27794                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27795                         }
27796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27797                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27798                         ndr->flags = _flags_save_uint8;
27799                 }
27800                 if (r->out.data_needed == NULL) {
27801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27802                 }
27803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27804                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27805         }
27806         return NDR_ERR_SUCCESS;
27807 }
27808
27809 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27810 {
27811         TALLOC_CTX *_mem_save_handle_0;
27812         TALLOC_CTX *_mem_save_value_needed_0;
27813         TALLOC_CTX *_mem_save_type_0;
27814         TALLOC_CTX *_mem_save_data_needed_0;
27815         if (flags & NDR_IN) {
27816                 ZERO_STRUCT(r->out);
27817
27818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27819                         NDR_PULL_ALLOC(ndr, r->in.handle);
27820                 }
27821                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27822                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27823                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27828                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27829                 ZERO_STRUCTP(r->out.value_needed);
27830                 NDR_PULL_ALLOC(ndr, r->out.type);
27831                 ZERO_STRUCTP(r->out.type);
27832                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27833                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27834                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27835                 ZERO_STRUCTP(r->out.data_needed);
27836         }
27837         if (flags & NDR_OUT) {
27838                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27839                 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));
27840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27841                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27842                 }
27843                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27844                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27847                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27848                         NDR_PULL_ALLOC(ndr, r->out.type);
27849                 }
27850                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27851                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27852                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27853                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27854                 {
27855                         uint32_t _flags_save_uint8 = ndr->flags;
27856                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27857                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27858                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27859                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27860                         }
27861                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27862                         ndr->flags = _flags_save_uint8;
27863                 }
27864                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27865                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27866                 }
27867                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27868                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27870                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27871                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27872                 if (r->out.value_name) {
27873                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27874                 }
27875                 if (r->out.data) {
27876                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27877                 }
27878         }
27879         return NDR_ERR_SUCCESS;
27880 }
27881
27882 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27883 {
27884         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27885         ndr->depth++;
27886         if (flags & NDR_SET_VALUES) {
27887                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27888         }
27889         if (flags & NDR_IN) {
27890                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27891                 ndr->depth++;
27892                 ndr_print_ptr(ndr, "handle", r->in.handle);
27893                 ndr->depth++;
27894                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27895                 ndr->depth--;
27896                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27897                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27898                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27899                 ndr->depth--;
27900         }
27901         if (flags & NDR_OUT) {
27902                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27903                 ndr->depth++;
27904                 ndr_print_string(ndr, "value_name", r->out.value_name);
27905                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27906                 ndr->depth++;
27907                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27908                 ndr->depth--;
27909                 ndr_print_ptr(ndr, "type", r->out.type);
27910                 ndr->depth++;
27911                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27912                 ndr->depth--;
27913                 ndr_print_ptr(ndr, "data", r->out.data);
27914                 ndr->depth++;
27915                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27916                 ndr->depth--;
27917                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27918                 ndr->depth++;
27919                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27920                 ndr->depth--;
27921                 ndr_print_WERROR(ndr, "result", r->out.result);
27922                 ndr->depth--;
27923         }
27924         ndr->depth--;
27925 }
27926
27927 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27928 {
27929         if (flags & NDR_IN) {
27930                 if (r->in.handle == NULL) {
27931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27932                 }
27933                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27934                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27935                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27936                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27937                 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));
27938         }
27939         if (flags & NDR_OUT) {
27940                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27941         }
27942         return NDR_ERR_SUCCESS;
27943 }
27944
27945 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27946 {
27947         TALLOC_CTX *_mem_save_handle_0;
27948         if (flags & NDR_IN) {
27949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27950                         NDR_PULL_ALLOC(ndr, r->in.handle);
27951                 }
27952                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27953                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27954                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27956                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27957                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27958                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27959                         return 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));
27960                 }
27961                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27962                 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));
27963         }
27964         if (flags & NDR_OUT) {
27965                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27966         }
27967         return NDR_ERR_SUCCESS;
27968 }
27969
27970 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27971 {
27972         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27973         ndr->depth++;
27974         if (flags & NDR_SET_VALUES) {
27975                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27976         }
27977         if (flags & NDR_IN) {
27978                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27979                 ndr->depth++;
27980                 ndr_print_ptr(ndr, "handle", r->in.handle);
27981                 ndr->depth++;
27982                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27983                 ndr->depth--;
27984                 ndr_print_string(ndr, "value_name", r->in.value_name);
27985                 ndr->depth--;
27986         }
27987         if (flags & NDR_OUT) {
27988                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27989                 ndr->depth++;
27990                 ndr_print_WERROR(ndr, "result", r->out.result);
27991                 ndr->depth--;
27992         }
27993         ndr->depth--;
27994 }
27995
27996 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27997 {
27998         if (flags & NDR_IN) {
27999         }
28000         if (flags & NDR_OUT) {
28001                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28002         }
28003         return NDR_ERR_SUCCESS;
28004 }
28005
28006 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
28007 {
28008         if (flags & NDR_IN) {
28009         }
28010         if (flags & NDR_OUT) {
28011                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28012         }
28013         return NDR_ERR_SUCCESS;
28014 }
28015
28016 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
28017 {
28018         ndr_print_struct(ndr, name, "spoolss_4a");
28019         ndr->depth++;
28020         if (flags & NDR_SET_VALUES) {
28021                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28022         }
28023         if (flags & NDR_IN) {
28024                 ndr_print_struct(ndr, "in", "spoolss_4a");
28025                 ndr->depth++;
28026                 ndr->depth--;
28027         }
28028         if (flags & NDR_OUT) {
28029                 ndr_print_struct(ndr, "out", "spoolss_4a");
28030                 ndr->depth++;
28031                 ndr_print_WERROR(ndr, "result", r->out.result);
28032                 ndr->depth--;
28033         }
28034         ndr->depth--;
28035 }
28036
28037 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
28038 {
28039         if (flags & NDR_IN) {
28040         }
28041         if (flags & NDR_OUT) {
28042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28043         }
28044         return NDR_ERR_SUCCESS;
28045 }
28046
28047 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
28048 {
28049         if (flags & NDR_IN) {
28050         }
28051         if (flags & NDR_OUT) {
28052                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28053         }
28054         return NDR_ERR_SUCCESS;
28055 }
28056
28057 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
28058 {
28059         ndr_print_struct(ndr, name, "spoolss_4b");
28060         ndr->depth++;
28061         if (flags & NDR_SET_VALUES) {
28062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28063         }
28064         if (flags & NDR_IN) {
28065                 ndr_print_struct(ndr, "in", "spoolss_4b");
28066                 ndr->depth++;
28067                 ndr->depth--;
28068         }
28069         if (flags & NDR_OUT) {
28070                 ndr_print_struct(ndr, "out", "spoolss_4b");
28071                 ndr->depth++;
28072                 ndr_print_WERROR(ndr, "result", r->out.result);
28073                 ndr->depth--;
28074         }
28075         ndr->depth--;
28076 }
28077
28078 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
28079 {
28080         if (flags & NDR_IN) {
28081         }
28082         if (flags & NDR_OUT) {
28083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28084         }
28085         return NDR_ERR_SUCCESS;
28086 }
28087
28088 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
28089 {
28090         if (flags & NDR_IN) {
28091         }
28092         if (flags & NDR_OUT) {
28093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28094         }
28095         return NDR_ERR_SUCCESS;
28096 }
28097
28098 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
28099 {
28100         ndr_print_struct(ndr, name, "spoolss_4c");
28101         ndr->depth++;
28102         if (flags & NDR_SET_VALUES) {
28103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28104         }
28105         if (flags & NDR_IN) {
28106                 ndr_print_struct(ndr, "in", "spoolss_4c");
28107                 ndr->depth++;
28108                 ndr->depth--;
28109         }
28110         if (flags & NDR_OUT) {
28111                 ndr_print_struct(ndr, "out", "spoolss_4c");
28112                 ndr->depth++;
28113                 ndr_print_WERROR(ndr, "result", r->out.result);
28114                 ndr->depth--;
28115         }
28116         ndr->depth--;
28117 }
28118
28119 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterDataEx *r)
28120 {
28121         if (flags & NDR_IN) {
28122                 if (r->in.handle == NULL) {
28123                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28124                 }
28125                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28126                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28127                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28128                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28129                 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));
28130                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28131                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28132                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28133                 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));
28134                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28135                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
28136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
28137         }
28138         if (flags & NDR_OUT) {
28139                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28140         }
28141         return NDR_ERR_SUCCESS;
28142 }
28143
28144 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterDataEx *r)
28145 {
28146         if (flags & NDR_IN) {
28147                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28148         }
28149         if (flags & NDR_OUT) {
28150                 if (r->out.data == NULL) {
28151                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28152                 }
28153                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28154                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28155         }
28156         return NDR_ERR_SUCCESS;
28157 }
28158
28159 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
28160 {
28161         TALLOC_CTX *_mem_save_handle_0;
28162         if (flags & NDR_IN) {
28163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28164                         NDR_PULL_ALLOC(ndr, r->in.handle);
28165                 }
28166                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28167                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28168                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28170                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28171                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28172                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28173                         return 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));
28174                 }
28175                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28176                 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));
28177                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28178                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28179                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
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.value_name), ndr_get_array_length(ndr, &r->in.value_name));
28181                 }
28182                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28183                 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));
28184                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28185                 {
28186                         struct ndr_pull *_ndr_data;
28187                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
28188                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
28189                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
28190                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
28191                 }
28192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
28193         }
28194         if (flags & NDR_OUT) {
28195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28196         }
28197         return NDR_ERR_SUCCESS;
28198 }
28199
28200 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
28201 {
28202         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
28203         ndr->depth++;
28204         if (flags & NDR_SET_VALUES) {
28205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28206         }
28207         if (flags & NDR_IN) {
28208                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
28209                 ndr->depth++;
28210                 ndr_print_ptr(ndr, "handle", r->in.handle);
28211                 ndr->depth++;
28212                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28213                 ndr->depth--;
28214                 ndr_print_string(ndr, "key_name", r->in.key_name);
28215                 ndr_print_string(ndr, "value_name", r->in.value_name);
28216                 ndr_print_winreg_Type(ndr, "type", r->in.type);
28217                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
28218                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
28219                 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);
28220                 ndr->depth--;
28221         }
28222         if (flags & NDR_OUT) {
28223                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
28224                 ndr->depth++;
28225                 ndr_print_WERROR(ndr, "result", r->out.result);
28226                 ndr->depth--;
28227         }
28228         ndr->depth--;
28229 }
28230
28231 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterDataEx *r)
28232 {
28233         if (flags & NDR_IN) {
28234                 if (r->in.handle == NULL) {
28235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28236                 }
28237                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28238                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28239                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28240                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28241                 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));
28242                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28243                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28244                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28245                 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));
28246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28247         }
28248         if (flags & NDR_OUT) {
28249                 if (r->out.type == NULL) {
28250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28251                 }
28252                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28253                 if (r->out.data == NULL) {
28254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28255                 }
28256                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
28257                 if (r->out.needed == NULL) {
28258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28259                 }
28260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28262         }
28263         return NDR_ERR_SUCCESS;
28264 }
28265
28266 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterDataEx *r)
28267 {
28268         TALLOC_CTX *_mem_save_handle_0;
28269         TALLOC_CTX *_mem_save_type_0;
28270         TALLOC_CTX *_mem_save_data_0;
28271         TALLOC_CTX *_mem_save_needed_0;
28272         if (flags & NDR_IN) {
28273                 ZERO_STRUCT(r->out);
28274
28275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28276                         NDR_PULL_ALLOC(ndr, r->in.handle);
28277                 }
28278                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28279                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28280                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28282                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28283                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28284                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28285                         return 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));
28286                 }
28287                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28288                 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));
28289                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28290                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28291                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28292                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
28293                 }
28294                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28295                 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));
28296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28297                 NDR_PULL_ALLOC(ndr, r->out.type);
28298                 ZERO_STRUCTP(r->out.type);
28299                 NDR_PULL_ALLOC(ndr, r->out.data);
28300                 ZERO_STRUCTP(r->out.data);
28301                 NDR_PULL_ALLOC(ndr, r->out.needed);
28302                 ZERO_STRUCTP(r->out.needed);
28303         }
28304         if (flags & NDR_OUT) {
28305                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28306                         NDR_PULL_ALLOC(ndr, r->out.type);
28307                 }
28308                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28309                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28310                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28311                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28313                         NDR_PULL_ALLOC(ndr, r->out.data);
28314                 }
28315                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28316                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28317                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
28318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28319                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28320                         NDR_PULL_ALLOC(ndr, r->out.needed);
28321                 }
28322                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28323                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28325                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28326                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28327         }
28328         return NDR_ERR_SUCCESS;
28329 }
28330
28331 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterDataEx *r)
28332 {
28333         if (flags & NDR_IN) {
28334                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28335         }
28336         if (flags & NDR_OUT) {
28337                 if (r->out.data == NULL) {
28338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28339                 }
28340                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28341                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28342         }
28343         return NDR_ERR_SUCCESS;
28344 }
28345
28346 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterDataEx *r)
28347 {
28348         TALLOC_CTX *_mem_save_data_0;
28349         if (flags & NDR_IN) {
28350                 ZERO_STRUCT(r->out);
28351
28352                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28353                 NDR_PULL_ALLOC(ndr, r->out.data);
28354                 ZERO_STRUCTP(r->out.data);
28355         }
28356         if (flags & NDR_OUT) {
28357                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28358                         NDR_PULL_ALLOC(ndr, r->out.data);
28359                 }
28360                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28361                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28362                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
28363                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28365         }
28366         return NDR_ERR_SUCCESS;
28367 }
28368
28369 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28370 {
28371         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28372         ndr->depth++;
28373         if (flags & NDR_SET_VALUES) {
28374                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28375         }
28376         if (flags & NDR_IN) {
28377                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28378                 ndr->depth++;
28379                 ndr_print_ptr(ndr, "handle", r->in.handle);
28380                 ndr->depth++;
28381                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28382                 ndr->depth--;
28383                 ndr_print_string(ndr, "key_name", r->in.key_name);
28384                 ndr_print_string(ndr, "value_name", r->in.value_name);
28385                 ndr_print_uint32(ndr, "offered", r->in.offered);
28386                 ndr->depth--;
28387         }
28388         if (flags & NDR_OUT) {
28389                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28390                 ndr->depth++;
28391                 ndr_print_ptr(ndr, "type", r->out.type);
28392                 ndr->depth++;
28393                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28394                 ndr->depth--;
28395                 ndr_print_ptr(ndr, "data", r->out.data);
28396                 ndr->depth++;
28397                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
28398                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
28399                 ndr->depth--;
28400                 ndr_print_ptr(ndr, "needed", r->out.needed);
28401                 ndr->depth++;
28402                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28403                 ndr->depth--;
28404                 ndr_print_WERROR(ndr, "result", r->out.result);
28405                 ndr->depth--;
28406         }
28407         ndr->depth--;
28408 }
28409
28410 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28411 {
28412         if (flags & NDR_IN) {
28413                 if (r->in.handle == NULL) {
28414                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28415                 }
28416                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28417                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28418                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28419                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28420                 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));
28421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28422         }
28423         if (flags & NDR_OUT) {
28424                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28425                 if (r->out.needed == NULL) {
28426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28427                 }
28428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28429                 if (r->out.count == NULL) {
28430                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28431                 }
28432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28433                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28434         }
28435         return NDR_ERR_SUCCESS;
28436 }
28437
28438 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28439 {
28440         TALLOC_CTX *_mem_save_handle_0;
28441         TALLOC_CTX *_mem_save_needed_0;
28442         TALLOC_CTX *_mem_save_count_0;
28443         if (flags & NDR_IN) {
28444                 ZERO_STRUCT(r->out);
28445
28446                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28447                         NDR_PULL_ALLOC(ndr, r->in.handle);
28448                 }
28449                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28450                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28451                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28452                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28453                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28454                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28455                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28456                         return 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));
28457                 }
28458                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28459                 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));
28460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28461                 NDR_PULL_ALLOC(ndr, r->out.needed);
28462                 ZERO_STRUCTP(r->out.needed);
28463                 NDR_PULL_ALLOC(ndr, r->out.count);
28464                 ZERO_STRUCTP(r->out.count);
28465         }
28466         if (flags & NDR_OUT) {
28467                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28468                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28469                         NDR_PULL_ALLOC(ndr, r->out.needed);
28470                 }
28471                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28472                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28474                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28476                         NDR_PULL_ALLOC(ndr, r->out.count);
28477                 }
28478                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28479                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28482                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28483         }
28484         return NDR_ERR_SUCCESS;
28485 }
28486
28487 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28488 {
28489         uint32_t cntr_info_0;
28490         if (flags & NDR_IN) {
28491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28492         }
28493         if (flags & NDR_OUT) {
28494                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28495                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28496                 }
28497                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28498                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28499                 }
28500         }
28501         return NDR_ERR_SUCCESS;
28502 }
28503
28504 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28505 {
28506         uint32_t cntr_info_0;
28507         TALLOC_CTX *_mem_save_info_0;
28508         if (flags & NDR_IN) {
28509                 ZERO_STRUCT(r->out);
28510
28511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28512         }
28513         if (flags & NDR_OUT) {
28514                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28515                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28516                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28517                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28518                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28519                 }
28520                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28521                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28522                 }
28523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28524         }
28525         return NDR_ERR_SUCCESS;
28526 }
28527
28528 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28529 {
28530         uint32_t cntr_info_2;
28531         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28532         ndr->depth++;
28533         if (flags & NDR_SET_VALUES) {
28534                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28535         }
28536         if (flags & NDR_IN) {
28537                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28538                 ndr->depth++;
28539                 ndr_print_ptr(ndr, "handle", r->in.handle);
28540                 ndr->depth++;
28541                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28542                 ndr->depth--;
28543                 ndr_print_string(ndr, "key_name", r->in.key_name);
28544                 ndr_print_uint32(ndr, "offered", r->in.offered);
28545                 ndr->depth--;
28546         }
28547         if (flags & NDR_OUT) {
28548                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28549                 ndr->depth++;
28550                 ndr_print_ptr(ndr, "count", r->out.count);
28551                 ndr->depth++;
28552                 ndr_print_uint32(ndr, "count", *r->out.count);
28553                 ndr->depth--;
28554                 ndr_print_ptr(ndr, "info", r->out.info);
28555                 ndr->depth++;
28556                 ndr_print_ptr(ndr, "info", *r->out.info);
28557                 ndr->depth++;
28558                 if (*r->out.info) {
28559                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28560                         ndr->depth++;
28561                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28562                                 char *idx_2=NULL;
28563                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28564                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28565                                         free(idx_2);
28566                                 }
28567                         }
28568                         ndr->depth--;
28569                 }
28570                 ndr->depth--;
28571                 ndr->depth--;
28572                 ndr_print_ptr(ndr, "needed", r->out.needed);
28573                 ndr->depth++;
28574                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28575                 ndr->depth--;
28576                 ndr_print_WERROR(ndr, "result", r->out.result);
28577                 ndr->depth--;
28578         }
28579         ndr->depth--;
28580 }
28581
28582 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28583 {
28584         if (flags & NDR_IN) {
28585                 if (r->in.handle == NULL) {
28586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28587                 }
28588                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28589                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28590                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28591                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28592                 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));
28593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28594         }
28595         if (flags & NDR_OUT) {
28596                 if (r->out._ndr_size == NULL) {
28597                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28598                 }
28599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28600                 if (r->out.key_buffer == NULL) {
28601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28602                 }
28603                 {
28604                         struct ndr_push *_ndr_key_buffer;
28605                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28606                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28607                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28608                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28609                 }
28610                 if (r->out.needed == NULL) {
28611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28612                 }
28613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28614                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28615         }
28616         return NDR_ERR_SUCCESS;
28617 }
28618
28619 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28620 {
28621         TALLOC_CTX *_mem_save_handle_0;
28622         TALLOC_CTX *_mem_save__ndr_size_0;
28623         TALLOC_CTX *_mem_save_key_buffer_0;
28624         TALLOC_CTX *_mem_save_needed_0;
28625         if (flags & NDR_IN) {
28626                 ZERO_STRUCT(r->out);
28627
28628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28629                         NDR_PULL_ALLOC(ndr, r->in.handle);
28630                 }
28631                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28632                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28635                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28636                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28637                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28638                         return 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));
28639                 }
28640                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28641                 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));
28642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28643                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28644                 ZERO_STRUCTP(r->out._ndr_size);
28645                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28646                 ZERO_STRUCTP(r->out.key_buffer);
28647                 NDR_PULL_ALLOC(ndr, r->out.needed);
28648                 ZERO_STRUCTP(r->out.needed);
28649         }
28650         if (flags & NDR_OUT) {
28651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28652                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28653                 }
28654                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
28655                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
28656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
28657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
28658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28659                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28660                 }
28661                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28662                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28663                 {
28664                         struct ndr_pull *_ndr_key_buffer;
28665                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28666                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28667                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28668                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28669                 }
28670                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28671                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28672                         NDR_PULL_ALLOC(ndr, r->out.needed);
28673                 }
28674                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28675                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28677                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28678                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28679         }
28680         return NDR_ERR_SUCCESS;
28681 }
28682
28683 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28684 {
28685         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28686         ndr->depth++;
28687         if (flags & NDR_SET_VALUES) {
28688                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28689         }
28690         if (flags & NDR_IN) {
28691                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28692                 ndr->depth++;
28693                 ndr_print_ptr(ndr, "handle", r->in.handle);
28694                 ndr->depth++;
28695                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28696                 ndr->depth--;
28697                 ndr_print_string(ndr, "key_name", r->in.key_name);
28698                 ndr_print_uint32(ndr, "offered", r->in.offered);
28699                 ndr->depth--;
28700         }
28701         if (flags & NDR_OUT) {
28702                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28703                 ndr->depth++;
28704                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
28705                 ndr->depth++;
28706                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
28707                 ndr->depth--;
28708                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28709                 ndr->depth++;
28710                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
28711                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
28712                 ndr->depth--;
28713                 ndr_print_ptr(ndr, "needed", r->out.needed);
28714                 ndr->depth++;
28715                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28716                 ndr->depth--;
28717                 ndr_print_WERROR(ndr, "result", r->out.result);
28718                 ndr->depth--;
28719         }
28720         ndr->depth--;
28721 }
28722
28723 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28724 {
28725         if (flags & NDR_IN) {
28726                 if (r->in.handle == NULL) {
28727                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28728                 }
28729                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28730                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28731                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28732                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28733                 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));
28734                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28735                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28736                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28737                 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));
28738         }
28739         if (flags & NDR_OUT) {
28740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28741         }
28742         return NDR_ERR_SUCCESS;
28743 }
28744
28745 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28746 {
28747         TALLOC_CTX *_mem_save_handle_0;
28748         if (flags & NDR_IN) {
28749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28750                         NDR_PULL_ALLOC(ndr, r->in.handle);
28751                 }
28752                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28753                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28754                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28756                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28757                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28758                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28759                         return 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));
28760                 }
28761                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28762                 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));
28763                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28764                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28765                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28766                         return 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));
28767                 }
28768                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28769                 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));
28770         }
28771         if (flags & NDR_OUT) {
28772                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28773         }
28774         return NDR_ERR_SUCCESS;
28775 }
28776
28777 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28778 {
28779         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28780         ndr->depth++;
28781         if (flags & NDR_SET_VALUES) {
28782                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28783         }
28784         if (flags & NDR_IN) {
28785                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28786                 ndr->depth++;
28787                 ndr_print_ptr(ndr, "handle", r->in.handle);
28788                 ndr->depth++;
28789                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28790                 ndr->depth--;
28791                 ndr_print_string(ndr, "key_name", r->in.key_name);
28792                 ndr_print_string(ndr, "value_name", r->in.value_name);
28793                 ndr->depth--;
28794         }
28795         if (flags & NDR_OUT) {
28796                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28797                 ndr->depth++;
28798                 ndr_print_WERROR(ndr, "result", r->out.result);
28799                 ndr->depth--;
28800         }
28801         ndr->depth--;
28802 }
28803
28804 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28805 {
28806         if (flags & NDR_IN) {
28807                 if (r->in.handle == NULL) {
28808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28809                 }
28810                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28811                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28812                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28813                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28814                 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));
28815         }
28816         if (flags & NDR_OUT) {
28817                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28818         }
28819         return NDR_ERR_SUCCESS;
28820 }
28821
28822 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28823 {
28824         TALLOC_CTX *_mem_save_handle_0;
28825         if (flags & NDR_IN) {
28826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28827                         NDR_PULL_ALLOC(ndr, r->in.handle);
28828                 }
28829                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28831                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28833                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28834                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28835                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28836                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
28837                 }
28838                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28839                 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));
28840         }
28841         if (flags & NDR_OUT) {
28842                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28843         }
28844         return NDR_ERR_SUCCESS;
28845 }
28846
28847 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28848 {
28849         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28850         ndr->depth++;
28851         if (flags & NDR_SET_VALUES) {
28852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28853         }
28854         if (flags & NDR_IN) {
28855                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28856                 ndr->depth++;
28857                 ndr_print_ptr(ndr, "handle", r->in.handle);
28858                 ndr->depth++;
28859                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28860                 ndr->depth--;
28861                 ndr_print_string(ndr, "key_name", r->in.key_name);
28862                 ndr->depth--;
28863         }
28864         if (flags & NDR_OUT) {
28865                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28866                 ndr->depth++;
28867                 ndr_print_WERROR(ndr, "result", r->out.result);
28868                 ndr->depth--;
28869         }
28870         ndr->depth--;
28871 }
28872
28873 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28874 {
28875         if (flags & NDR_IN) {
28876         }
28877         if (flags & NDR_OUT) {
28878                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28879         }
28880         return NDR_ERR_SUCCESS;
28881 }
28882
28883 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28884 {
28885         if (flags & NDR_IN) {
28886         }
28887         if (flags & NDR_OUT) {
28888                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28889         }
28890         return NDR_ERR_SUCCESS;
28891 }
28892
28893 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28894 {
28895         ndr_print_struct(ndr, name, "spoolss_53");
28896         ndr->depth++;
28897         if (flags & NDR_SET_VALUES) {
28898                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28899         }
28900         if (flags & NDR_IN) {
28901                 ndr_print_struct(ndr, "in", "spoolss_53");
28902                 ndr->depth++;
28903                 ndr->depth--;
28904         }
28905         if (flags & NDR_OUT) {
28906                 ndr_print_struct(ndr, "out", "spoolss_53");
28907                 ndr->depth++;
28908                 ndr_print_WERROR(ndr, "result", r->out.result);
28909                 ndr->depth--;
28910         }
28911         ndr->depth--;
28912 }
28913
28914 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28915 {
28916         if (flags & NDR_IN) {
28917                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28918                 if (r->in.server) {
28919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28920                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28922                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28923                 }
28924                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28925                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28926                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28927                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28928                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28929                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28930                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28931                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28932                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28934         }
28935         if (flags & NDR_OUT) {
28936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28937         }
28938         return NDR_ERR_SUCCESS;
28939 }
28940
28941 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28942 {
28943         uint32_t _ptr_server;
28944         TALLOC_CTX *_mem_save_server_0;
28945         if (flags & NDR_IN) {
28946                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28947                 if (_ptr_server) {
28948                         NDR_PULL_ALLOC(ndr, r->in.server);
28949                 } else {
28950                         r->in.server = NULL;
28951                 }
28952                 if (r->in.server) {
28953                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28954                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28955                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28956                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28957                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28958                                 return 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));
28959                         }
28960                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28961                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28963                 }
28964                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28965                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28966                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28967                         return 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));
28968                 }
28969                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28970                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28971                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28972                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28973                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28974                         return 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));
28975                 }
28976                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28977                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28978                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28980         }
28981         if (flags & NDR_OUT) {
28982                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28983         }
28984         return NDR_ERR_SUCCESS;
28985 }
28986
28987 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28988 {
28989         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28990         ndr->depth++;
28991         if (flags & NDR_SET_VALUES) {
28992                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28993         }
28994         if (flags & NDR_IN) {
28995                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28996                 ndr->depth++;
28997                 ndr_print_ptr(ndr, "server", r->in.server);
28998                 ndr->depth++;
28999                 if (r->in.server) {
29000                         ndr_print_string(ndr, "server", r->in.server);
29001                 }
29002                 ndr->depth--;
29003                 ndr_print_string(ndr, "architecture", r->in.architecture);
29004                 ndr_print_string(ndr, "driver", r->in.driver);
29005                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
29006                 ndr_print_uint32(ndr, "version", r->in.version);
29007                 ndr->depth--;
29008         }
29009         if (flags & NDR_OUT) {
29010                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
29011                 ndr->depth++;
29012                 ndr_print_WERROR(ndr, "result", r->out.result);
29013                 ndr->depth--;
29014         }
29015         ndr->depth--;
29016 }
29017
29018 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
29019 {
29020         if (flags & NDR_IN) {
29021         }
29022         if (flags & NDR_OUT) {
29023                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29024         }
29025         return NDR_ERR_SUCCESS;
29026 }
29027
29028 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
29029 {
29030         if (flags & NDR_IN) {
29031         }
29032         if (flags & NDR_OUT) {
29033                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29034         }
29035         return NDR_ERR_SUCCESS;
29036 }
29037
29038 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
29039 {
29040         ndr_print_struct(ndr, name, "spoolss_55");
29041         ndr->depth++;
29042         if (flags & NDR_SET_VALUES) {
29043                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29044         }
29045         if (flags & NDR_IN) {
29046                 ndr_print_struct(ndr, "in", "spoolss_55");
29047                 ndr->depth++;
29048                 ndr->depth--;
29049         }
29050         if (flags & NDR_OUT) {
29051                 ndr_print_struct(ndr, "out", "spoolss_55");
29052                 ndr->depth++;
29053                 ndr_print_WERROR(ndr, "result", r->out.result);
29054                 ndr->depth--;
29055         }
29056         ndr->depth--;
29057 }
29058
29059 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
29060 {
29061         if (flags & NDR_IN) {
29062         }
29063         if (flags & NDR_OUT) {
29064                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29065         }
29066         return NDR_ERR_SUCCESS;
29067 }
29068
29069 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
29070 {
29071         if (flags & NDR_IN) {
29072         }
29073         if (flags & NDR_OUT) {
29074                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29075         }
29076         return NDR_ERR_SUCCESS;
29077 }
29078
29079 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
29080 {
29081         ndr_print_struct(ndr, name, "spoolss_56");
29082         ndr->depth++;
29083         if (flags & NDR_SET_VALUES) {
29084                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29085         }
29086         if (flags & NDR_IN) {
29087                 ndr_print_struct(ndr, "in", "spoolss_56");
29088                 ndr->depth++;
29089                 ndr->depth--;
29090         }
29091         if (flags & NDR_OUT) {
29092                 ndr_print_struct(ndr, "out", "spoolss_56");
29093                 ndr->depth++;
29094                 ndr_print_WERROR(ndr, "result", r->out.result);
29095                 ndr->depth--;
29096         }
29097         ndr->depth--;
29098 }
29099
29100 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
29101 {
29102         if (flags & NDR_IN) {
29103         }
29104         if (flags & NDR_OUT) {
29105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29106         }
29107         return NDR_ERR_SUCCESS;
29108 }
29109
29110 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
29111 {
29112         if (flags & NDR_IN) {
29113         }
29114         if (flags & NDR_OUT) {
29115                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29116         }
29117         return NDR_ERR_SUCCESS;
29118 }
29119
29120 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
29121 {
29122         ndr_print_struct(ndr, name, "spoolss_57");
29123         ndr->depth++;
29124         if (flags & NDR_SET_VALUES) {
29125                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29126         }
29127         if (flags & NDR_IN) {
29128                 ndr_print_struct(ndr, "in", "spoolss_57");
29129                 ndr->depth++;
29130                 ndr->depth--;
29131         }
29132         if (flags & NDR_OUT) {
29133                 ndr_print_struct(ndr, "out", "spoolss_57");
29134                 ndr->depth++;
29135                 ndr_print_WERROR(ndr, "result", r->out.result);
29136                 ndr->depth--;
29137         }
29138         ndr->depth--;
29139 }
29140
29141 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
29142 {
29143         if (flags & NDR_IN) {
29144                 if (r->in.handle == NULL) {
29145                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29146                 }
29147                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29148                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29149                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29150                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29151                 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));
29152                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
29153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
29154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
29155                 if (r->in.status_code == NULL) {
29156                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29157                 }
29158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
29159         }
29160         if (flags & NDR_OUT) {
29161                 if (r->out.out_data == NULL) {
29162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29163                 }
29164                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
29165                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
29166                 if (r->out.needed == NULL) {
29167                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29168                 }
29169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
29170                 if (r->out.status_code == NULL) {
29171                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29172                 }
29173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
29174                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29175         }
29176         return NDR_ERR_SUCCESS;
29177 }
29178
29179 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
29180 {
29181         TALLOC_CTX *_mem_save_handle_0;
29182         TALLOC_CTX *_mem_save_needed_0;
29183         TALLOC_CTX *_mem_save_status_code_0;
29184         if (flags & NDR_IN) {
29185                 ZERO_STRUCT(r->out);
29186
29187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29188                         NDR_PULL_ALLOC(ndr, r->in.handle);
29189                 }
29190                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29191                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29192                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29194                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
29195                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
29196                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
29197                         return 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));
29198                 }
29199                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
29200                 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));
29201                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
29202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
29203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
29204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29205                         NDR_PULL_ALLOC(ndr, r->in.status_code);
29206                 }
29207                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29208                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
29209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
29210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29211                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
29212                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
29213                 NDR_PULL_ALLOC(ndr, r->out.needed);
29214                 ZERO_STRUCTP(r->out.needed);
29215                 NDR_PULL_ALLOC(ndr, r->out.status_code);
29216                 *r->out.status_code = *r->in.status_code;
29217         }
29218         if (flags & NDR_OUT) {
29219                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
29220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29221                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
29222                 }
29223                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
29224                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29225                         NDR_PULL_ALLOC(ndr, r->out.needed);
29226                 }
29227                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29228                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29232                         NDR_PULL_ALLOC(ndr, r->out.status_code);
29233                 }
29234                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29235                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
29236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
29237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29238                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29239                 if (r->out.out_data) {
29240                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
29241                 }
29242         }
29243         return NDR_ERR_SUCCESS;
29244 }
29245
29246 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
29247 {
29248         ndr_print_struct(ndr, name, "spoolss_XcvData");
29249         ndr->depth++;
29250         if (flags & NDR_SET_VALUES) {
29251                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29252         }
29253         if (flags & NDR_IN) {
29254                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
29255                 ndr->depth++;
29256                 ndr_print_ptr(ndr, "handle", r->in.handle);
29257                 ndr->depth++;
29258                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29259                 ndr->depth--;
29260                 ndr_print_string(ndr, "function_name", r->in.function_name);
29261                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
29262                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
29263                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
29264                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
29265                 ndr->depth++;
29266                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
29267                 ndr->depth--;
29268                 ndr->depth--;
29269         }
29270         if (flags & NDR_OUT) {
29271                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
29272                 ndr->depth++;
29273                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
29274                 ndr->depth++;
29275                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
29276                 ndr->depth--;
29277                 ndr_print_ptr(ndr, "needed", r->out.needed);
29278                 ndr->depth++;
29279                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29280                 ndr->depth--;
29281                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
29282                 ndr->depth++;
29283                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
29284                 ndr->depth--;
29285                 ndr_print_WERROR(ndr, "result", r->out.result);
29286                 ndr->depth--;
29287         }
29288         ndr->depth--;
29289 }
29290
29291 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
29292 {
29293         if (flags & NDR_IN) {
29294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29295                 if (r->in.servername) {
29296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29300                 }
29301                 if (r->in.info_ctr == NULL) {
29302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29303                 }
29304                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29305                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
29306         }
29307         if (flags & NDR_OUT) {
29308                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29309         }
29310         return NDR_ERR_SUCCESS;
29311 }
29312
29313 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
29314 {
29315         uint32_t _ptr_servername;
29316         TALLOC_CTX *_mem_save_servername_0;
29317         TALLOC_CTX *_mem_save_info_ctr_0;
29318         if (flags & NDR_IN) {
29319                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29320                 if (_ptr_servername) {
29321                         NDR_PULL_ALLOC(ndr, r->in.servername);
29322                 } else {
29323                         r->in.servername = NULL;
29324                 }
29325                 if (r->in.servername) {
29326                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29327                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29330                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29331                                 return 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));
29332                         }
29333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29334                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29336                 }
29337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29338                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
29339                 }
29340                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
29341                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
29342                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
29344                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
29345         }
29346         if (flags & NDR_OUT) {
29347                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29348         }
29349         return NDR_ERR_SUCCESS;
29350 }
29351
29352 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
29353 {
29354         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
29355         ndr->depth++;
29356         if (flags & NDR_SET_VALUES) {
29357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29358         }
29359         if (flags & NDR_IN) {
29360                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29361                 ndr->depth++;
29362                 ndr_print_ptr(ndr, "servername", r->in.servername);
29363                 ndr->depth++;
29364                 if (r->in.servername) {
29365                         ndr_print_string(ndr, "servername", r->in.servername);
29366                 }
29367                 ndr->depth--;
29368                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29369                 ndr->depth++;
29370                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29371                 ndr->depth--;
29372                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29373                 ndr->depth--;
29374         }
29375         if (flags & NDR_OUT) {
29376                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29377                 ndr->depth++;
29378                 ndr_print_WERROR(ndr, "result", r->out.result);
29379                 ndr->depth--;
29380         }
29381         ndr->depth--;
29382 }
29383
29384 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29385 {
29386         if (flags & NDR_IN) {
29387         }
29388         if (flags & NDR_OUT) {
29389                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29390         }
29391         return NDR_ERR_SUCCESS;
29392 }
29393
29394 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29395 {
29396         if (flags & NDR_IN) {
29397         }
29398         if (flags & NDR_OUT) {
29399                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29400         }
29401         return NDR_ERR_SUCCESS;
29402 }
29403
29404 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29405 {
29406         ndr_print_struct(ndr, name, "spoolss_5a");
29407         ndr->depth++;
29408         if (flags & NDR_SET_VALUES) {
29409                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29410         }
29411         if (flags & NDR_IN) {
29412                 ndr_print_struct(ndr, "in", "spoolss_5a");
29413                 ndr->depth++;
29414                 ndr->depth--;
29415         }
29416         if (flags & NDR_OUT) {
29417                 ndr_print_struct(ndr, "out", "spoolss_5a");
29418                 ndr->depth++;
29419                 ndr_print_WERROR(ndr, "result", r->out.result);
29420                 ndr->depth--;
29421         }
29422         ndr->depth--;
29423 }
29424
29425 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29426 {
29427         if (flags & NDR_IN) {
29428         }
29429         if (flags & NDR_OUT) {
29430                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29431         }
29432         return NDR_ERR_SUCCESS;
29433 }
29434
29435 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29436 {
29437         if (flags & NDR_IN) {
29438         }
29439         if (flags & NDR_OUT) {
29440                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29441         }
29442         return NDR_ERR_SUCCESS;
29443 }
29444
29445 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29446 {
29447         ndr_print_struct(ndr, name, "spoolss_5b");
29448         ndr->depth++;
29449         if (flags & NDR_SET_VALUES) {
29450                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29451         }
29452         if (flags & NDR_IN) {
29453                 ndr_print_struct(ndr, "in", "spoolss_5b");
29454                 ndr->depth++;
29455                 ndr->depth--;
29456         }
29457         if (flags & NDR_OUT) {
29458                 ndr_print_struct(ndr, "out", "spoolss_5b");
29459                 ndr->depth++;
29460                 ndr_print_WERROR(ndr, "result", r->out.result);
29461                 ndr->depth--;
29462         }
29463         ndr->depth--;
29464 }
29465
29466 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29467 {
29468         if (flags & NDR_IN) {
29469         }
29470         if (flags & NDR_OUT) {
29471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29472         }
29473         return NDR_ERR_SUCCESS;
29474 }
29475
29476 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29477 {
29478         if (flags & NDR_IN) {
29479         }
29480         if (flags & NDR_OUT) {
29481                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29482         }
29483         return NDR_ERR_SUCCESS;
29484 }
29485
29486 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29487 {
29488         ndr_print_struct(ndr, name, "spoolss_5c");
29489         ndr->depth++;
29490         if (flags & NDR_SET_VALUES) {
29491                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29492         }
29493         if (flags & NDR_IN) {
29494                 ndr_print_struct(ndr, "in", "spoolss_5c");
29495                 ndr->depth++;
29496                 ndr->depth--;
29497         }
29498         if (flags & NDR_OUT) {
29499                 ndr_print_struct(ndr, "out", "spoolss_5c");
29500                 ndr->depth++;
29501                 ndr_print_WERROR(ndr, "result", r->out.result);
29502                 ndr->depth--;
29503         }
29504         ndr->depth--;
29505 }
29506
29507 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29508 {
29509         if (flags & NDR_IN) {
29510         }
29511         if (flags & NDR_OUT) {
29512                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29513         }
29514         return NDR_ERR_SUCCESS;
29515 }
29516
29517 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29518 {
29519         if (flags & NDR_IN) {
29520         }
29521         if (flags & NDR_OUT) {
29522                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29523         }
29524         return NDR_ERR_SUCCESS;
29525 }
29526
29527 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29528 {
29529         ndr_print_struct(ndr, name, "spoolss_5d");
29530         ndr->depth++;
29531         if (flags & NDR_SET_VALUES) {
29532                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29533         }
29534         if (flags & NDR_IN) {
29535                 ndr_print_struct(ndr, "in", "spoolss_5d");
29536                 ndr->depth++;
29537                 ndr->depth--;
29538         }
29539         if (flags & NDR_OUT) {
29540                 ndr_print_struct(ndr, "out", "spoolss_5d");
29541                 ndr->depth++;
29542                 ndr_print_WERROR(ndr, "result", r->out.result);
29543                 ndr->depth--;
29544         }
29545         ndr->depth--;
29546 }
29547
29548 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29549 {
29550         if (flags & NDR_IN) {
29551         }
29552         if (flags & NDR_OUT) {
29553                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29554         }
29555         return NDR_ERR_SUCCESS;
29556 }
29557
29558 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29559 {
29560         if (flags & NDR_IN) {
29561         }
29562         if (flags & NDR_OUT) {
29563                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29564         }
29565         return NDR_ERR_SUCCESS;
29566 }
29567
29568 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29569 {
29570         ndr_print_struct(ndr, name, "spoolss_5e");
29571         ndr->depth++;
29572         if (flags & NDR_SET_VALUES) {
29573                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29574         }
29575         if (flags & NDR_IN) {
29576                 ndr_print_struct(ndr, "in", "spoolss_5e");
29577                 ndr->depth++;
29578                 ndr->depth--;
29579         }
29580         if (flags & NDR_OUT) {
29581                 ndr_print_struct(ndr, "out", "spoolss_5e");
29582                 ndr->depth++;
29583                 ndr_print_WERROR(ndr, "result", r->out.result);
29584                 ndr->depth--;
29585         }
29586         ndr->depth--;
29587 }
29588
29589 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29590 {
29591         if (flags & NDR_IN) {
29592         }
29593         if (flags & NDR_OUT) {
29594                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29595         }
29596         return NDR_ERR_SUCCESS;
29597 }
29598
29599 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29600 {
29601         if (flags & NDR_IN) {
29602         }
29603         if (flags & NDR_OUT) {
29604                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29605         }
29606         return NDR_ERR_SUCCESS;
29607 }
29608
29609 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29610 {
29611         ndr_print_struct(ndr, name, "spoolss_5f");
29612         ndr->depth++;
29613         if (flags & NDR_SET_VALUES) {
29614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29615         }
29616         if (flags & NDR_IN) {
29617                 ndr_print_struct(ndr, "in", "spoolss_5f");
29618                 ndr->depth++;
29619                 ndr->depth--;
29620         }
29621         if (flags & NDR_OUT) {
29622                 ndr_print_struct(ndr, "out", "spoolss_5f");
29623                 ndr->depth++;
29624                 ndr_print_WERROR(ndr, "result", r->out.result);
29625                 ndr->depth--;
29626         }
29627         ndr->depth--;
29628 }
29629
29630 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29631 {
29632         if (flags & NDR_IN) {
29633         }
29634         if (flags & NDR_OUT) {
29635                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29636         }
29637         return NDR_ERR_SUCCESS;
29638 }
29639
29640 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29641 {
29642         if (flags & NDR_IN) {
29643         }
29644         if (flags & NDR_OUT) {
29645                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29646         }
29647         return NDR_ERR_SUCCESS;
29648 }
29649
29650 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29651 {
29652         ndr_print_struct(ndr, name, "spoolss_60");
29653         ndr->depth++;
29654         if (flags & NDR_SET_VALUES) {
29655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29656         }
29657         if (flags & NDR_IN) {
29658                 ndr_print_struct(ndr, "in", "spoolss_60");
29659                 ndr->depth++;
29660                 ndr->depth--;
29661         }
29662         if (flags & NDR_OUT) {
29663                 ndr_print_struct(ndr, "out", "spoolss_60");
29664                 ndr->depth++;
29665                 ndr_print_WERROR(ndr, "result", r->out.result);
29666                 ndr->depth--;
29667         }
29668         ndr->depth--;
29669 }
29670
29671 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29672 {
29673         if (flags & NDR_IN) {
29674         }
29675         if (flags & NDR_OUT) {
29676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29677         }
29678         return NDR_ERR_SUCCESS;
29679 }
29680
29681 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29682 {
29683         if (flags & NDR_IN) {
29684         }
29685         if (flags & NDR_OUT) {
29686                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29687         }
29688         return NDR_ERR_SUCCESS;
29689 }
29690
29691 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29692 {
29693         ndr_print_struct(ndr, name, "spoolss_61");
29694         ndr->depth++;
29695         if (flags & NDR_SET_VALUES) {
29696                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29697         }
29698         if (flags & NDR_IN) {
29699                 ndr_print_struct(ndr, "in", "spoolss_61");
29700                 ndr->depth++;
29701                 ndr->depth--;
29702         }
29703         if (flags & NDR_OUT) {
29704                 ndr_print_struct(ndr, "out", "spoolss_61");
29705                 ndr->depth++;
29706                 ndr_print_WERROR(ndr, "result", r->out.result);
29707                 ndr->depth--;
29708         }
29709         ndr->depth--;
29710 }
29711
29712 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29713 {
29714         if (flags & NDR_IN) {
29715         }
29716         if (flags & NDR_OUT) {
29717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29718         }
29719         return NDR_ERR_SUCCESS;
29720 }
29721
29722 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29723 {
29724         if (flags & NDR_IN) {
29725         }
29726         if (flags & NDR_OUT) {
29727                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29728         }
29729         return NDR_ERR_SUCCESS;
29730 }
29731
29732 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29733 {
29734         ndr_print_struct(ndr, name, "spoolss_62");
29735         ndr->depth++;
29736         if (flags & NDR_SET_VALUES) {
29737                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29738         }
29739         if (flags & NDR_IN) {
29740                 ndr_print_struct(ndr, "in", "spoolss_62");
29741                 ndr->depth++;
29742                 ndr->depth--;
29743         }
29744         if (flags & NDR_OUT) {
29745                 ndr_print_struct(ndr, "out", "spoolss_62");
29746                 ndr->depth++;
29747                 ndr_print_WERROR(ndr, "result", r->out.result);
29748                 ndr->depth--;
29749         }
29750         ndr->depth--;
29751 }
29752
29753 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29754 {
29755         if (flags & NDR_IN) {
29756         }
29757         if (flags & NDR_OUT) {
29758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29759         }
29760         return NDR_ERR_SUCCESS;
29761 }
29762
29763 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29764 {
29765         if (flags & NDR_IN) {
29766         }
29767         if (flags & NDR_OUT) {
29768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29769         }
29770         return NDR_ERR_SUCCESS;
29771 }
29772
29773 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29774 {
29775         ndr_print_struct(ndr, name, "spoolss_63");
29776         ndr->depth++;
29777         if (flags & NDR_SET_VALUES) {
29778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29779         }
29780         if (flags & NDR_IN) {
29781                 ndr_print_struct(ndr, "in", "spoolss_63");
29782                 ndr->depth++;
29783                 ndr->depth--;
29784         }
29785         if (flags & NDR_OUT) {
29786                 ndr_print_struct(ndr, "out", "spoolss_63");
29787                 ndr->depth++;
29788                 ndr_print_WERROR(ndr, "result", r->out.result);
29789                 ndr->depth--;
29790         }
29791         ndr->depth--;
29792 }
29793
29794 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29795 {
29796         if (flags & NDR_IN) {
29797         }
29798         if (flags & NDR_OUT) {
29799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29800         }
29801         return NDR_ERR_SUCCESS;
29802 }
29803
29804 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29805 {
29806         if (flags & NDR_IN) {
29807         }
29808         if (flags & NDR_OUT) {
29809                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29810         }
29811         return NDR_ERR_SUCCESS;
29812 }
29813
29814 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29815 {
29816         ndr_print_struct(ndr, name, "spoolss_64");
29817         ndr->depth++;
29818         if (flags & NDR_SET_VALUES) {
29819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29820         }
29821         if (flags & NDR_IN) {
29822                 ndr_print_struct(ndr, "in", "spoolss_64");
29823                 ndr->depth++;
29824                 ndr->depth--;
29825         }
29826         if (flags & NDR_OUT) {
29827                 ndr_print_struct(ndr, "out", "spoolss_64");
29828                 ndr->depth++;
29829                 ndr_print_WERROR(ndr, "result", r->out.result);
29830                 ndr->depth--;
29831         }
29832         ndr->depth--;
29833 }
29834
29835 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29836 {
29837         if (flags & NDR_IN) {
29838         }
29839         if (flags & NDR_OUT) {
29840                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29841         }
29842         return NDR_ERR_SUCCESS;
29843 }
29844
29845 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29846 {
29847         if (flags & NDR_IN) {
29848         }
29849         if (flags & NDR_OUT) {
29850                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29851         }
29852         return NDR_ERR_SUCCESS;
29853 }
29854
29855 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29856 {
29857         ndr_print_struct(ndr, name, "spoolss_65");
29858         ndr->depth++;
29859         if (flags & NDR_SET_VALUES) {
29860                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29861         }
29862         if (flags & NDR_IN) {
29863                 ndr_print_struct(ndr, "in", "spoolss_65");
29864                 ndr->depth++;
29865                 ndr->depth--;
29866         }
29867         if (flags & NDR_OUT) {
29868                 ndr_print_struct(ndr, "out", "spoolss_65");
29869                 ndr->depth++;
29870                 ndr_print_WERROR(ndr, "result", r->out.result);
29871                 ndr->depth--;
29872         }
29873         ndr->depth--;
29874 }
29875
29876 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29877 {
29878         uint32_t cntr_core_printer_drivers_1;
29879         if (flags & NDR_IN) {
29880                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29881                 if (r->in.servername) {
29882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29883                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29884                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29885                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29886                 }
29887                 if (r->in.architecture == NULL) {
29888                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29889                 }
29890                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29891                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29892                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29893                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29895                 if (r->in.core_driver_dependencies == NULL) {
29896                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29897                 }
29898                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29899                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29901         }
29902         if (flags & NDR_OUT) {
29903                 if (r->out.core_printer_drivers == NULL) {
29904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29905                 }
29906                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29907                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29908                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29909                 }
29910                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29911         }
29912         return NDR_ERR_SUCCESS;
29913 }
29914
29915 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29916 {
29917         uint32_t _ptr_servername;
29918         uint32_t cntr_core_printer_drivers_1;
29919         TALLOC_CTX *_mem_save_servername_0;
29920         TALLOC_CTX *_mem_save_core_printer_drivers_1;
29921         if (flags & NDR_IN) {
29922                 ZERO_STRUCT(r->out);
29923
29924                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29925                 if (_ptr_servername) {
29926                         NDR_PULL_ALLOC(ndr, r->in.servername);
29927                 } else {
29928                         r->in.servername = NULL;
29929                 }
29930                 if (r->in.servername) {
29931                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29932                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29935                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29936                                 return 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));
29937                         }
29938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29941                 }
29942                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29943                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29944                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29945                         return 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));
29946                 }
29947                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29948                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29950                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29951                 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));
29952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29953                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29954                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29955                 if (r->in.core_driver_dependencies) {
29956                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29957                 }
29958         }
29959         if (flags & NDR_OUT) {
29960                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29961                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29962                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29963                 }
29964                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29965                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29966                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29967                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29968                 }
29969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29970                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29971                 if (r->out.core_printer_drivers) {
29972                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29973                 }
29974         }
29975         return NDR_ERR_SUCCESS;
29976 }
29977
29978 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29979 {
29980         uint32_t cntr_core_printer_drivers_1;
29981         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29982         ndr->depth++;
29983         if (flags & NDR_SET_VALUES) {
29984                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29985         }
29986         if (flags & NDR_IN) {
29987                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29988                 ndr->depth++;
29989                 ndr_print_ptr(ndr, "servername", r->in.servername);
29990                 ndr->depth++;
29991                 if (r->in.servername) {
29992                         ndr_print_string(ndr, "servername", r->in.servername);
29993                 }
29994                 ndr->depth--;
29995                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29996                 ndr->depth++;
29997                 ndr_print_string(ndr, "architecture", r->in.architecture);
29998                 ndr->depth--;
29999                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
30000                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30001                 ndr->depth++;
30002                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30003                 ndr->depth--;
30004                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
30005                 ndr->depth--;
30006         }
30007         if (flags & NDR_OUT) {
30008                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
30009                 ndr->depth++;
30010                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
30011                 ndr->depth++;
30012                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
30013                 ndr->depth++;
30014                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
30015                         char *idx_1=NULL;
30016                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
30017                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
30018                                 free(idx_1);
30019                         }
30020                 }
30021                 ndr->depth--;
30022                 ndr->depth--;
30023                 ndr_print_WERROR(ndr, "result", r->out.result);
30024                 ndr->depth--;
30025         }
30026         ndr->depth--;
30027 }
30028
30029 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
30030 {
30031         if (flags & NDR_IN) {
30032         }
30033         if (flags & NDR_OUT) {
30034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30035         }
30036         return NDR_ERR_SUCCESS;
30037 }
30038
30039 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
30040 {
30041         if (flags & NDR_IN) {
30042         }
30043         if (flags & NDR_OUT) {
30044                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30045         }
30046         return NDR_ERR_SUCCESS;
30047 }
30048
30049 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
30050 {
30051         ndr_print_struct(ndr, name, "spoolss_67");
30052         ndr->depth++;
30053         if (flags & NDR_SET_VALUES) {
30054                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30055         }
30056         if (flags & NDR_IN) {
30057                 ndr_print_struct(ndr, "in", "spoolss_67");
30058                 ndr->depth++;
30059                 ndr->depth--;
30060         }
30061         if (flags & NDR_OUT) {
30062                 ndr_print_struct(ndr, "out", "spoolss_67");
30063                 ndr->depth++;
30064                 ndr_print_WERROR(ndr, "result", r->out.result);
30065                 ndr->depth--;
30066         }
30067         ndr->depth--;
30068 }
30069
30070 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30071 {
30072         if (flags & NDR_IN) {
30073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30074                 if (r->in.servername) {
30075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30078                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30079                 }
30080                 if (r->in.architecture == NULL) {
30081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30082                 }
30083                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30084                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30085                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30086                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
30088                 if (r->in.language) {
30089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30092                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30093                 }
30094                 if (r->in.package_id == NULL) {
30095                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30096                 }
30097                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30098                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30099                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30100                 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));
30101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
30102                 if (r->in.driver_package_cab) {
30103                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30104                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30105                 }
30106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30107         }
30108         if (flags & NDR_OUT) {
30109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
30110                 if (r->out.driver_package_cab) {
30111                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30112                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30113                 }
30114                 if (r->out.required == NULL) {
30115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30116                 }
30117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
30118                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30119         }
30120         return NDR_ERR_SUCCESS;
30121 }
30122
30123 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
30124 {
30125         uint32_t _ptr_servername;
30126         uint32_t _ptr_language;
30127         uint32_t _ptr_driver_package_cab;
30128         TALLOC_CTX *_mem_save_servername_0;
30129         TALLOC_CTX *_mem_save_language_0;
30130         TALLOC_CTX *_mem_save_driver_package_cab_0;
30131         TALLOC_CTX *_mem_save_required_0;
30132         if (flags & NDR_IN) {
30133                 ZERO_STRUCT(r->out);
30134
30135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30136                 if (_ptr_servername) {
30137                         NDR_PULL_ALLOC(ndr, r->in.servername);
30138                 } else {
30139                         r->in.servername = NULL;
30140                 }
30141                 if (r->in.servername) {
30142                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30143                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30144                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30145                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30146                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30147                                 return 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));
30148                         }
30149                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30150                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30152                 }
30153                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30154                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30155                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30156                         return 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));
30157                 }
30158                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30159                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
30161                 if (_ptr_language) {
30162                         NDR_PULL_ALLOC(ndr, r->in.language);
30163                 } else {
30164                         r->in.language = NULL;
30165                 }
30166                 if (r->in.language) {
30167                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
30168                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
30169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
30170                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
30171                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
30172                                 return 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));
30173                         }
30174                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
30175                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
30176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
30177                 }
30178                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
30179                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
30180                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
30181                         return 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));
30182                 }
30183                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
30184                 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));
30185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30186                 if (_ptr_driver_package_cab) {
30187                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
30188                 } else {
30189                         r->in.driver_package_cab = NULL;
30190                 }
30191                 if (r->in.driver_package_cab) {
30192                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30193                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
30194                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
30195                         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));
30196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30197                 }
30198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
30199                 NDR_PULL_ALLOC(ndr, r->out.required);
30200                 ZERO_STRUCTP(r->out.required);
30201                 if (r->in.driver_package_cab) {
30202                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
30203                 }
30204         }
30205         if (flags & NDR_OUT) {
30206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30207                 if (_ptr_driver_package_cab) {
30208                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
30209                 } else {
30210                         r->out.driver_package_cab = NULL;
30211                 }
30212                 if (r->out.driver_package_cab) {
30213                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30214                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
30215                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
30216                         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));
30217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30218                 }
30219                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30220                         NDR_PULL_ALLOC(ndr, r->out.required);
30221                 }
30222                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
30223                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
30224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
30225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
30226                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30227                 if (r->out.driver_package_cab) {
30228                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
30229                 }
30230         }
30231         return NDR_ERR_SUCCESS;
30232 }
30233
30234 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30235 {
30236         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
30237         ndr->depth++;
30238         if (flags & NDR_SET_VALUES) {
30239                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30240         }
30241         if (flags & NDR_IN) {
30242                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
30243                 ndr->depth++;
30244                 ndr_print_ptr(ndr, "servername", r->in.servername);
30245                 ndr->depth++;
30246                 if (r->in.servername) {
30247                         ndr_print_string(ndr, "servername", r->in.servername);
30248                 }
30249                 ndr->depth--;
30250                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30251                 ndr->depth++;
30252                 ndr_print_string(ndr, "architecture", r->in.architecture);
30253                 ndr->depth--;
30254                 ndr_print_ptr(ndr, "language", r->in.language);
30255                 ndr->depth++;
30256                 if (r->in.language) {
30257                         ndr_print_string(ndr, "language", r->in.language);
30258                 }
30259                 ndr->depth--;
30260                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
30261                 ndr->depth++;
30262                 ndr_print_string(ndr, "package_id", r->in.package_id);
30263                 ndr->depth--;
30264                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
30265                 ndr->depth++;
30266                 if (r->in.driver_package_cab) {
30267                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
30268                 }
30269                 ndr->depth--;
30270                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
30271                 ndr->depth--;
30272         }
30273         if (flags & NDR_OUT) {
30274                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
30275                 ndr->depth++;
30276                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
30277                 ndr->depth++;
30278                 if (r->out.driver_package_cab) {
30279                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
30280                 }
30281                 ndr->depth--;
30282                 ndr_print_ptr(ndr, "required", r->out.required);
30283                 ndr->depth++;
30284                 ndr_print_uint32(ndr, "required", *r->out.required);
30285                 ndr->depth--;
30286                 ndr_print_WERROR(ndr, "result", r->out.result);
30287                 ndr->depth--;
30288         }
30289         ndr->depth--;
30290 }
30291
30292 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
30293 {
30294         if (flags & NDR_IN) {
30295         }
30296         if (flags & NDR_OUT) {
30297                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30298         }
30299         return NDR_ERR_SUCCESS;
30300 }
30301
30302 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
30303 {
30304         if (flags & NDR_IN) {
30305         }
30306         if (flags & NDR_OUT) {
30307                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30308         }
30309         return NDR_ERR_SUCCESS;
30310 }
30311
30312 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
30313 {
30314         ndr_print_struct(ndr, name, "spoolss_69");
30315         ndr->depth++;
30316         if (flags & NDR_SET_VALUES) {
30317                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30318         }
30319         if (flags & NDR_IN) {
30320                 ndr_print_struct(ndr, "in", "spoolss_69");
30321                 ndr->depth++;
30322                 ndr->depth--;
30323         }
30324         if (flags & NDR_OUT) {
30325                 ndr_print_struct(ndr, "out", "spoolss_69");
30326                 ndr->depth++;
30327                 ndr_print_WERROR(ndr, "result", r->out.result);
30328                 ndr->depth--;
30329         }
30330         ndr->depth--;
30331 }
30332
30333 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
30334 {
30335         if (flags & NDR_IN) {
30336         }
30337         if (flags & NDR_OUT) {
30338                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30339         }
30340         return NDR_ERR_SUCCESS;
30341 }
30342
30343 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
30344 {
30345         if (flags & NDR_IN) {
30346         }
30347         if (flags & NDR_OUT) {
30348                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30349         }
30350         return NDR_ERR_SUCCESS;
30351 }
30352
30353 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
30354 {
30355         ndr_print_struct(ndr, name, "spoolss_6a");
30356         ndr->depth++;
30357         if (flags & NDR_SET_VALUES) {
30358                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30359         }
30360         if (flags & NDR_IN) {
30361                 ndr_print_struct(ndr, "in", "spoolss_6a");
30362                 ndr->depth++;
30363                 ndr->depth--;
30364         }
30365         if (flags & NDR_OUT) {
30366                 ndr_print_struct(ndr, "out", "spoolss_6a");
30367                 ndr->depth++;
30368                 ndr_print_WERROR(ndr, "result", r->out.result);
30369                 ndr->depth--;
30370         }
30371         ndr->depth--;
30372 }
30373
30374 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30375 {
30376         if (flags & NDR_IN) {
30377         }
30378         if (flags & NDR_OUT) {
30379                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30380         }
30381         return NDR_ERR_SUCCESS;
30382 }
30383
30384 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30385 {
30386         if (flags & NDR_IN) {
30387         }
30388         if (flags & NDR_OUT) {
30389                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30390         }
30391         return NDR_ERR_SUCCESS;
30392 }
30393
30394 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30395 {
30396         ndr_print_struct(ndr, name, "spoolss_6b");
30397         ndr->depth++;
30398         if (flags & NDR_SET_VALUES) {
30399                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30400         }
30401         if (flags & NDR_IN) {
30402                 ndr_print_struct(ndr, "in", "spoolss_6b");
30403                 ndr->depth++;
30404                 ndr->depth--;
30405         }
30406         if (flags & NDR_OUT) {
30407                 ndr_print_struct(ndr, "out", "spoolss_6b");
30408                 ndr->depth++;
30409                 ndr_print_WERROR(ndr, "result", r->out.result);
30410                 ndr->depth--;
30411         }
30412         ndr->depth--;
30413 }
30414
30415 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30416 {
30417         if (flags & NDR_IN) {
30418         }
30419         if (flags & NDR_OUT) {
30420                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30421         }
30422         return NDR_ERR_SUCCESS;
30423 }
30424
30425 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30426 {
30427         if (flags & NDR_IN) {
30428         }
30429         if (flags & NDR_OUT) {
30430                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30431         }
30432         return NDR_ERR_SUCCESS;
30433 }
30434
30435 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30436 {
30437         ndr_print_struct(ndr, name, "spoolss_6c");
30438         ndr->depth++;
30439         if (flags & NDR_SET_VALUES) {
30440                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30441         }
30442         if (flags & NDR_IN) {
30443                 ndr_print_struct(ndr, "in", "spoolss_6c");
30444                 ndr->depth++;
30445                 ndr->depth--;
30446         }
30447         if (flags & NDR_OUT) {
30448                 ndr_print_struct(ndr, "out", "spoolss_6c");
30449                 ndr->depth++;
30450                 ndr_print_WERROR(ndr, "result", r->out.result);
30451                 ndr->depth--;
30452         }
30453         ndr->depth--;
30454 }
30455
30456 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30457 {
30458         if (flags & NDR_IN) {
30459         }
30460         if (flags & NDR_OUT) {
30461                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30462         }
30463         return NDR_ERR_SUCCESS;
30464 }
30465
30466 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30467 {
30468         if (flags & NDR_IN) {
30469         }
30470         if (flags & NDR_OUT) {
30471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30472         }
30473         return NDR_ERR_SUCCESS;
30474 }
30475
30476 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30477 {
30478         ndr_print_struct(ndr, name, "spoolss_6d");
30479         ndr->depth++;
30480         if (flags & NDR_SET_VALUES) {
30481                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30482         }
30483         if (flags & NDR_IN) {
30484                 ndr_print_struct(ndr, "in", "spoolss_6d");
30485                 ndr->depth++;
30486                 ndr->depth--;
30487         }
30488         if (flags & NDR_OUT) {
30489                 ndr_print_struct(ndr, "out", "spoolss_6d");
30490                 ndr->depth++;
30491                 ndr_print_WERROR(ndr, "result", r->out.result);
30492                 ndr->depth--;
30493         }
30494         ndr->depth--;
30495 }
30496
30497 static const struct ndr_interface_call spoolss_calls[] = {
30498         {
30499                 "spoolss_EnumPrinters",
30500                 sizeof(struct spoolss_EnumPrinters),
30501                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30502                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30503                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30504                 false,
30505         },
30506         {
30507                 "spoolss_OpenPrinter",
30508                 sizeof(struct spoolss_OpenPrinter),
30509                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30510                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30511                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30512                 false,
30513         },
30514         {
30515                 "spoolss_SetJob",
30516                 sizeof(struct spoolss_SetJob),
30517                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30518                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30519                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30520                 false,
30521         },
30522         {
30523                 "spoolss_GetJob",
30524                 sizeof(struct spoolss_GetJob),
30525                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30526                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30527                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30528                 false,
30529         },
30530         {
30531                 "spoolss_EnumJobs",
30532                 sizeof(struct spoolss_EnumJobs),
30533                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30534                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30535                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30536                 false,
30537         },
30538         {
30539                 "spoolss_AddPrinter",
30540                 sizeof(struct spoolss_AddPrinter),
30541                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30542                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30543                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30544                 false,
30545         },
30546         {
30547                 "spoolss_DeletePrinter",
30548                 sizeof(struct spoolss_DeletePrinter),
30549                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30550                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30551                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30552                 false,
30553         },
30554         {
30555                 "spoolss_SetPrinter",
30556                 sizeof(struct spoolss_SetPrinter),
30557                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30558                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30559                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30560                 false,
30561         },
30562         {
30563                 "spoolss_GetPrinter",
30564                 sizeof(struct spoolss_GetPrinter),
30565                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30566                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30567                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30568                 false,
30569         },
30570         {
30571                 "spoolss_AddPrinterDriver",
30572                 sizeof(struct spoolss_AddPrinterDriver),
30573                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30574                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30575                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30576                 false,
30577         },
30578         {
30579                 "spoolss_EnumPrinterDrivers",
30580                 sizeof(struct spoolss_EnumPrinterDrivers),
30581                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30582                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30583                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30584                 false,
30585         },
30586         {
30587                 "spoolss_GetPrinterDriver",
30588                 sizeof(struct spoolss_GetPrinterDriver),
30589                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30590                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30591                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30592                 false,
30593         },
30594         {
30595                 "spoolss_GetPrinterDriverDirectory",
30596                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30597                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30598                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30599                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30600                 false,
30601         },
30602         {
30603                 "spoolss_DeletePrinterDriver",
30604                 sizeof(struct spoolss_DeletePrinterDriver),
30605                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30606                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30607                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30608                 false,
30609         },
30610         {
30611                 "spoolss_AddPrintProcessor",
30612                 sizeof(struct spoolss_AddPrintProcessor),
30613                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30614                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30615                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30616                 false,
30617         },
30618         {
30619                 "spoolss_EnumPrintProcessors",
30620                 sizeof(struct spoolss_EnumPrintProcessors),
30621                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30622                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30623                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30624                 false,
30625         },
30626         {
30627                 "spoolss_GetPrintProcessorDirectory",
30628                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30629                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30630                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30631                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30632                 false,
30633         },
30634         {
30635                 "spoolss_StartDocPrinter",
30636                 sizeof(struct spoolss_StartDocPrinter),
30637                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30638                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30639                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30640                 false,
30641         },
30642         {
30643                 "spoolss_StartPagePrinter",
30644                 sizeof(struct spoolss_StartPagePrinter),
30645                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30646                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30647                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30648                 false,
30649         },
30650         {
30651                 "spoolss_WritePrinter",
30652                 sizeof(struct spoolss_WritePrinter),
30653                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30654                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30655                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30656                 false,
30657         },
30658         {
30659                 "spoolss_EndPagePrinter",
30660                 sizeof(struct spoolss_EndPagePrinter),
30661                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30662                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30663                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30664                 false,
30665         },
30666         {
30667                 "spoolss_AbortPrinter",
30668                 sizeof(struct spoolss_AbortPrinter),
30669                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30670                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30671                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30672                 false,
30673         },
30674         {
30675                 "spoolss_ReadPrinter",
30676                 sizeof(struct spoolss_ReadPrinter),
30677                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30678                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30679                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30680                 false,
30681         },
30682         {
30683                 "spoolss_EndDocPrinter",
30684                 sizeof(struct spoolss_EndDocPrinter),
30685                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30686                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30687                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30688                 false,
30689         },
30690         {
30691                 "spoolss_AddJob",
30692                 sizeof(struct spoolss_AddJob),
30693                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30694                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30695                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
30696                 false,
30697         },
30698         {
30699                 "spoolss_ScheduleJob",
30700                 sizeof(struct spoolss_ScheduleJob),
30701                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30702                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30703                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30704                 false,
30705         },
30706         {
30707                 "spoolss_GetPrinterData",
30708                 sizeof(struct spoolss_GetPrinterData),
30709                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30710                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30711                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30712                 false,
30713         },
30714         {
30715                 "spoolss_SetPrinterData",
30716                 sizeof(struct spoolss_SetPrinterData),
30717                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30718                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30719                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30720                 false,
30721         },
30722         {
30723                 "spoolss_WaitForPrinterChange",
30724                 sizeof(struct spoolss_WaitForPrinterChange),
30725                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30726                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30727                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30728                 false,
30729         },
30730         {
30731                 "spoolss_ClosePrinter",
30732                 sizeof(struct spoolss_ClosePrinter),
30733                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30734                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30735                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30736                 false,
30737         },
30738         {
30739                 "spoolss_AddForm",
30740                 sizeof(struct spoolss_AddForm),
30741                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30742                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30743                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
30744                 false,
30745         },
30746         {
30747                 "spoolss_DeleteForm",
30748                 sizeof(struct spoolss_DeleteForm),
30749                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30750                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30751                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30752                 false,
30753         },
30754         {
30755                 "spoolss_GetForm",
30756                 sizeof(struct spoolss_GetForm),
30757                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30758                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30759                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
30760                 false,
30761         },
30762         {
30763                 "spoolss_SetForm",
30764                 sizeof(struct spoolss_SetForm),
30765                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30766                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30767                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
30768                 false,
30769         },
30770         {
30771                 "spoolss_EnumForms",
30772                 sizeof(struct spoolss_EnumForms),
30773                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30774                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30775                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30776                 false,
30777         },
30778         {
30779                 "spoolss_EnumPorts",
30780                 sizeof(struct spoolss_EnumPorts),
30781                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30782                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30783                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30784                 false,
30785         },
30786         {
30787                 "spoolss_EnumMonitors",
30788                 sizeof(struct spoolss_EnumMonitors),
30789                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30790                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30791                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30792                 false,
30793         },
30794         {
30795                 "spoolss_AddPort",
30796                 sizeof(struct spoolss_AddPort),
30797                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30798                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30799                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30800                 false,
30801         },
30802         {
30803                 "spoolss_ConfigurePort",
30804                 sizeof(struct spoolss_ConfigurePort),
30805                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30806                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30807                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30808                 false,
30809         },
30810         {
30811                 "spoolss_DeletePort",
30812                 sizeof(struct spoolss_DeletePort),
30813                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30814                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30815                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30816                 false,
30817         },
30818         {
30819                 "spoolss_CreatePrinterIC",
30820                 sizeof(struct spoolss_CreatePrinterIC),
30821                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30822                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30823                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30824                 false,
30825         },
30826         {
30827                 "spoolss_PlayGDIScriptOnPrinterIC",
30828                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30829                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30830                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30831                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30832                 false,
30833         },
30834         {
30835                 "spoolss_DeletePrinterIC",
30836                 sizeof(struct spoolss_DeletePrinterIC),
30837                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30838                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30839                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30840                 false,
30841         },
30842         {
30843                 "spoolss_AddPrinterConnection",
30844                 sizeof(struct spoolss_AddPrinterConnection),
30845                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30846                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30847                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30848                 false,
30849         },
30850         {
30851                 "spoolss_DeletePrinterConnection",
30852                 sizeof(struct spoolss_DeletePrinterConnection),
30853                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30854                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30855                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30856                 false,
30857         },
30858         {
30859                 "spoolss_PrinterMessageBox",
30860                 sizeof(struct spoolss_PrinterMessageBox),
30861                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30862                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30863                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30864                 false,
30865         },
30866         {
30867                 "spoolss_AddMonitor",
30868                 sizeof(struct spoolss_AddMonitor),
30869                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30870                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30871                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30872                 false,
30873         },
30874         {
30875                 "spoolss_DeleteMonitor",
30876                 sizeof(struct spoolss_DeleteMonitor),
30877                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30878                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30879                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30880                 false,
30881         },
30882         {
30883                 "spoolss_DeletePrintProcessor",
30884                 sizeof(struct spoolss_DeletePrintProcessor),
30885                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30886                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30887                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30888                 false,
30889         },
30890         {
30891                 "spoolss_AddPrintProvidor",
30892                 sizeof(struct spoolss_AddPrintProvidor),
30893                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30894                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30895                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30896                 false,
30897         },
30898         {
30899                 "spoolss_DeletePrintProvidor",
30900                 sizeof(struct spoolss_DeletePrintProvidor),
30901                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30902                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30903                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30904                 false,
30905         },
30906         {
30907                 "spoolss_EnumPrintProcDataTypes",
30908                 sizeof(struct spoolss_EnumPrintProcDataTypes),
30909                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30910                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30911                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30912                 false,
30913         },
30914         {
30915                 "spoolss_ResetPrinter",
30916                 sizeof(struct spoolss_ResetPrinter),
30917                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30918                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30919                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30920                 false,
30921         },
30922         {
30923                 "spoolss_GetPrinterDriver2",
30924                 sizeof(struct spoolss_GetPrinterDriver2),
30925                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30926                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30927                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30928                 false,
30929         },
30930         {
30931                 "spoolss_FindFirstPrinterChangeNotification",
30932                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30933                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30934                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30935                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30936                 false,
30937         },
30938         {
30939                 "spoolss_FindNextPrinterChangeNotification",
30940                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
30941                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30942                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30943                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30944                 false,
30945         },
30946         {
30947                 "spoolss_FindClosePrinterNotify",
30948                 sizeof(struct spoolss_FindClosePrinterNotify),
30949                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30950                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30951                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30952                 false,
30953         },
30954         {
30955                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30956                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30957                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30958                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30959                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30960                 false,
30961         },
30962         {
30963                 "spoolss_ReplyOpenPrinter",
30964                 sizeof(struct spoolss_ReplyOpenPrinter),
30965                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30966                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30967                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30968                 false,
30969         },
30970         {
30971                 "spoolss_RouterReplyPrinter",
30972                 sizeof(struct spoolss_RouterReplyPrinter),
30973                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30974                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30975                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30976                 false,
30977         },
30978         {
30979                 "spoolss_ReplyClosePrinter",
30980                 sizeof(struct spoolss_ReplyClosePrinter),
30981                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30982                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30983                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30984                 false,
30985         },
30986         {
30987                 "spoolss_AddPortEx",
30988                 sizeof(struct spoolss_AddPortEx),
30989                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30990                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30991                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30992                 false,
30993         },
30994         {
30995                 "spoolss_RouterFindFirstPrinterChangeNotification",
30996                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30997                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30998                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30999                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
31000                 false,
31001         },
31002         {
31003                 "spoolss_SpoolerInit",
31004                 sizeof(struct spoolss_SpoolerInit),
31005                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
31006                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
31007                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
31008                 false,
31009         },
31010         {
31011                 "spoolss_ResetPrinterEx",
31012                 sizeof(struct spoolss_ResetPrinterEx),
31013                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
31014                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
31015                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
31016                 false,
31017         },
31018         {
31019                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
31020                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
31021                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31022                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31023                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31024                 false,
31025         },
31026         {
31027                 "spoolss_RouterReplyPrinterEx",
31028                 sizeof(struct spoolss_RouterReplyPrinterEx),
31029                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
31030                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
31031                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
31032                 false,
31033         },
31034         {
31035                 "spoolss_RouterRefreshPrinterChangeNotify",
31036                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
31037                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
31038                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
31039                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
31040                 false,
31041         },
31042         {
31043                 "spoolss_44",
31044                 sizeof(struct spoolss_44),
31045                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
31046                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
31047                 (ndr_print_function_t) ndr_print_spoolss_44,
31048                 false,
31049         },
31050         {
31051                 "spoolss_OpenPrinterEx",
31052                 sizeof(struct spoolss_OpenPrinterEx),
31053                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
31054                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
31055                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
31056                 false,
31057         },
31058         {
31059                 "spoolss_AddPrinterEx",
31060                 sizeof(struct spoolss_AddPrinterEx),
31061                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
31062                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
31063                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
31064                 false,
31065         },
31066         {
31067                 "spoolss_47",
31068                 sizeof(struct spoolss_47),
31069                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
31070                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
31071                 (ndr_print_function_t) ndr_print_spoolss_47,
31072                 false,
31073         },
31074         {
31075                 "spoolss_EnumPrinterData",
31076                 sizeof(struct spoolss_EnumPrinterData),
31077                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
31078                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
31079                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
31080                 false,
31081         },
31082         {
31083                 "spoolss_DeletePrinterData",
31084                 sizeof(struct spoolss_DeletePrinterData),
31085                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
31086                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
31087                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
31088                 false,
31089         },
31090         {
31091                 "spoolss_4a",
31092                 sizeof(struct spoolss_4a),
31093                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
31094                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
31095                 (ndr_print_function_t) ndr_print_spoolss_4a,
31096                 false,
31097         },
31098         {
31099                 "spoolss_4b",
31100                 sizeof(struct spoolss_4b),
31101                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
31102                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
31103                 (ndr_print_function_t) ndr_print_spoolss_4b,
31104                 false,
31105         },
31106         {
31107                 "spoolss_4c",
31108                 sizeof(struct spoolss_4c),
31109                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
31110                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
31111                 (ndr_print_function_t) ndr_print_spoolss_4c,
31112                 false,
31113         },
31114         {
31115                 "spoolss_SetPrinterDataEx",
31116                 sizeof(struct spoolss_SetPrinterDataEx),
31117                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
31118                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
31119                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
31120                 false,
31121         },
31122         {
31123                 "spoolss_GetPrinterDataEx",
31124                 sizeof(struct spoolss_GetPrinterDataEx),
31125                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
31126                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
31127                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
31128                 false,
31129         },
31130         {
31131                 "spoolss_EnumPrinterDataEx",
31132                 sizeof(struct spoolss_EnumPrinterDataEx),
31133                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
31134                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
31135                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
31136                 false,
31137         },
31138         {
31139                 "spoolss_EnumPrinterKey",
31140                 sizeof(struct spoolss_EnumPrinterKey),
31141                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
31142                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
31143                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
31144                 false,
31145         },
31146         {
31147                 "spoolss_DeletePrinterDataEx",
31148                 sizeof(struct spoolss_DeletePrinterDataEx),
31149                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
31150                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
31151                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
31152                 false,
31153         },
31154         {
31155                 "spoolss_DeletePrinterKey",
31156                 sizeof(struct spoolss_DeletePrinterKey),
31157                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
31158                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
31159                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
31160                 false,
31161         },
31162         {
31163                 "spoolss_53",
31164                 sizeof(struct spoolss_53),
31165                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
31166                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
31167                 (ndr_print_function_t) ndr_print_spoolss_53,
31168                 false,
31169         },
31170         {
31171                 "spoolss_DeletePrinterDriverEx",
31172                 sizeof(struct spoolss_DeletePrinterDriverEx),
31173                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
31174                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
31175                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
31176                 false,
31177         },
31178         {
31179                 "spoolss_55",
31180                 sizeof(struct spoolss_55),
31181                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
31182                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
31183                 (ndr_print_function_t) ndr_print_spoolss_55,
31184                 false,
31185         },
31186         {
31187                 "spoolss_56",
31188                 sizeof(struct spoolss_56),
31189                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
31190                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
31191                 (ndr_print_function_t) ndr_print_spoolss_56,
31192                 false,
31193         },
31194         {
31195                 "spoolss_57",
31196                 sizeof(struct spoolss_57),
31197                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
31198                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
31199                 (ndr_print_function_t) ndr_print_spoolss_57,
31200                 false,
31201         },
31202         {
31203                 "spoolss_XcvData",
31204                 sizeof(struct spoolss_XcvData),
31205                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
31206                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
31207                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
31208                 false,
31209         },
31210         {
31211                 "spoolss_AddPrinterDriverEx",
31212                 sizeof(struct spoolss_AddPrinterDriverEx),
31213                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
31214                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
31215                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
31216                 false,
31217         },
31218         {
31219                 "spoolss_5a",
31220                 sizeof(struct spoolss_5a),
31221                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
31222                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
31223                 (ndr_print_function_t) ndr_print_spoolss_5a,
31224                 false,
31225         },
31226         {
31227                 "spoolss_5b",
31228                 sizeof(struct spoolss_5b),
31229                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
31230                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
31231                 (ndr_print_function_t) ndr_print_spoolss_5b,
31232                 false,
31233         },
31234         {
31235                 "spoolss_5c",
31236                 sizeof(struct spoolss_5c),
31237                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
31238                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
31239                 (ndr_print_function_t) ndr_print_spoolss_5c,
31240                 false,
31241         },
31242         {
31243                 "spoolss_5d",
31244                 sizeof(struct spoolss_5d),
31245                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
31246                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
31247                 (ndr_print_function_t) ndr_print_spoolss_5d,
31248                 false,
31249         },
31250         {
31251                 "spoolss_5e",
31252                 sizeof(struct spoolss_5e),
31253                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
31254                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
31255                 (ndr_print_function_t) ndr_print_spoolss_5e,
31256                 false,
31257         },
31258         {
31259                 "spoolss_5f",
31260                 sizeof(struct spoolss_5f),
31261                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
31262                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
31263                 (ndr_print_function_t) ndr_print_spoolss_5f,
31264                 false,
31265         },
31266         {
31267                 "spoolss_60",
31268                 sizeof(struct spoolss_60),
31269                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
31270                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
31271                 (ndr_print_function_t) ndr_print_spoolss_60,
31272                 false,
31273         },
31274         {
31275                 "spoolss_61",
31276                 sizeof(struct spoolss_61),
31277                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
31278                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
31279                 (ndr_print_function_t) ndr_print_spoolss_61,
31280                 false,
31281         },
31282         {
31283                 "spoolss_62",
31284                 sizeof(struct spoolss_62),
31285                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
31286                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
31287                 (ndr_print_function_t) ndr_print_spoolss_62,
31288                 false,
31289         },
31290         {
31291                 "spoolss_63",
31292                 sizeof(struct spoolss_63),
31293                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
31294                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
31295                 (ndr_print_function_t) ndr_print_spoolss_63,
31296                 false,
31297         },
31298         {
31299                 "spoolss_64",
31300                 sizeof(struct spoolss_64),
31301                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
31302                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
31303                 (ndr_print_function_t) ndr_print_spoolss_64,
31304                 false,
31305         },
31306         {
31307                 "spoolss_65",
31308                 sizeof(struct spoolss_65),
31309                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
31310                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
31311                 (ndr_print_function_t) ndr_print_spoolss_65,
31312                 false,
31313         },
31314         {
31315                 "spoolss_GetCorePrinterDrivers",
31316                 sizeof(struct spoolss_GetCorePrinterDrivers),
31317                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
31318                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
31319                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
31320                 false,
31321         },
31322         {
31323                 "spoolss_67",
31324                 sizeof(struct spoolss_67),
31325                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
31326                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
31327                 (ndr_print_function_t) ndr_print_spoolss_67,
31328                 false,
31329         },
31330         {
31331                 "spoolss_GetPrinterDriverPackagePath",
31332                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
31333                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
31334                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
31335                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
31336                 false,
31337         },
31338         {
31339                 "spoolss_69",
31340                 sizeof(struct spoolss_69),
31341                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
31342                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
31343                 (ndr_print_function_t) ndr_print_spoolss_69,
31344                 false,
31345         },
31346         {
31347                 "spoolss_6a",
31348                 sizeof(struct spoolss_6a),
31349                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
31350                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
31351                 (ndr_print_function_t) ndr_print_spoolss_6a,
31352                 false,
31353         },
31354         {
31355                 "spoolss_6b",
31356                 sizeof(struct spoolss_6b),
31357                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
31358                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
31359                 (ndr_print_function_t) ndr_print_spoolss_6b,
31360                 false,
31361         },
31362         {
31363                 "spoolss_6c",
31364                 sizeof(struct spoolss_6c),
31365                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31366                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31367                 (ndr_print_function_t) ndr_print_spoolss_6c,
31368                 false,
31369         },
31370         {
31371                 "spoolss_6d",
31372                 sizeof(struct spoolss_6d),
31373                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31374                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31375                 (ndr_print_function_t) ndr_print_spoolss_6d,
31376                 false,
31377         },
31378         { NULL, 0, NULL, NULL, NULL, false }
31379 };
31380
31381 static const char * const spoolss_endpoint_strings[] = {
31382         "ncacn_np:[\\pipe\\spoolss]",
31383 };
31384
31385 static const struct ndr_interface_string_array spoolss_endpoints = {
31386         .count  = 1,
31387         .names  = spoolss_endpoint_strings
31388 };
31389
31390 static const char * const spoolss_authservice_strings[] = {
31391         "host",
31392 };
31393
31394 static const struct ndr_interface_string_array spoolss_authservices = {
31395         .count  = 1,
31396         .names  = spoolss_authservice_strings
31397 };
31398
31399
31400 const struct ndr_interface_table ndr_table_spoolss = {
31401         .name           = "spoolss",
31402         .syntax_id      = {
31403                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31404                 NDR_SPOOLSS_VERSION
31405         },
31406         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31407         .num_calls      = 110,
31408         .calls          = spoolss_calls,
31409         .endpoints      = &spoolss_endpoints,
31410         .authservices   = &spoolss_authservices
31411 };
31412