librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  48 {
  49         ndr_print_struct(ndr, name, "spoolss_Time");
  50         ndr->depth++;
  51         ndr_print_uint16(ndr, "year", r->year);
  52         ndr_print_uint16(ndr, "month", r->month);
  53         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  54         ndr_print_uint16(ndr, "day", r->day);
  55         ndr_print_uint16(ndr, "hour", r->hour);
  56         ndr_print_uint16(ndr, "minute", r->minute);
  57         ndr_print_uint16(ndr, "second", r->second);
  58         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  59         ndr->depth--;
  60 }
  61
  62 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  63 {
  64         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  65 }
  66
  67 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  68 {
  69         if (ndr_flags & NDR_SCALARS) {
  70                 NDR_CHECK(ndr_push_align(ndr, 5));
  71                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  72                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  73                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  74         }
  75         if (ndr_flags & NDR_BUFFERS) {
  76                 if (r->time) {
  77                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  78                 }
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  84 {
  85         uint32_t _ptr_time;
  86         TALLOC_CTX *_mem_save_time_0;
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_pull_align(ndr, 5));
  89                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  90                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  91                 if (_ptr_time) {
  92                         NDR_PULL_ALLOC(ndr, r->time);
  93                 } else {
  94                         r->time = NULL;
  95                 }
  96                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  97         }
  98         if (ndr_flags & NDR_BUFFERS) {
  99                 if (r->time) {
 100                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
 101                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
 102                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
 103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 110 {
 111         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 112         ndr->depth++;
 113         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 114         ndr_print_ptr(ndr, "time", r->time);
 115         ndr->depth++;
 116         if (r->time) {
 117                 ndr_print_spoolss_Time(ndr, "time", r->time);
 118         }
 119         ndr->depth--;
 120         ndr->depth--;
 121 }
 122
 123 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 124 {
 125         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 130 {
 131         uint16_t v;
 132         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 133         *r = v;
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 143                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 144                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 145         }
 146         ndr_print_enum(ndr, name, "ENUM", val, r);
 147 }
 148
 149 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 150 {
 151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 152         return NDR_ERR_SUCCESS;
 153 }
 154
 155 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 156 {
 157         uint32_t v;
 158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 159         *r = v;
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 164 {
 165         const char *val = NULL;
 166
 167         switch (r) {
 168                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 169                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 170                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 171                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 172                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 173         }
 174         ndr_print_enum(ndr, name, "ENUM", val, r);
 175 }
 176
 177 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 178 {
 179         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 184 {
 185         uint32_t v;
 186         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 187         *r = v;
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 192 {
 193         const char *val = NULL;
 194
 195         switch (r) {
 196                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 197                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 198                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 199         }
 200         ndr_print_enum(ndr, name, "ENUM", val, r);
 201 }
 202
 203 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 204 {
 205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 210 {
 211         uint32_t v;
 212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 213         *r = v;
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 218 {
 219         const char *val = NULL;
 220
 221         switch (r) {
 222                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 223                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 224                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 225                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 226                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 227         }
 228         ndr_print_enum(ndr, name, "ENUM", val, r);
 229 }
 230
 231 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 232 {
 233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 238 {
 239         uint32_t v;
 240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 241         *r = v;
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 246 {
 247         ndr_print_uint32(ndr, name, r);
 248         ndr->depth++;
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 274         ndr->depth--;
 275 }
 276
 277 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 278 {
 279         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 284 {
 285         uint32_t v;
 286         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 287         *r = v;
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 292 {
 293         ndr_print_uint32(ndr, name, r);
 294         ndr->depth++;
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 308         ndr->depth--;
 309 }
 310
 311 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 312 {
 313         if (ndr_flags & NDR_SCALARS) {
 314                 NDR_CHECK(ndr_push_align(ndr, 5));
 315                 {
 316                         uint32_t _flags_save_string = ndr->flags;
 317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 319                         ndr->flags = _flags_save_string;
 320                 }
 321                 {
 322                         uint32_t _flags_save_string = ndr->flags;
 323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 325                         ndr->flags = _flags_save_string;
 326                 }
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 330                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 340                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 342                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 346                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 349                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 354                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 355         }
 356         if (ndr_flags & NDR_BUFFERS) {
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 360                         if (r->printername) {
 361                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                         }
 364                         ndr->flags = _flags_save_string;
 365                 }
 366                 {
 367                         uint32_t _flags_save_string = ndr->flags;
 368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 369                         if (r->servername) {
 370                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 371                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 372                         }
 373                         ndr->flags = _flags_save_string;
 374                 }
 375         }
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 380 {
 381         uint32_t _ptr_printername;
 382         TALLOC_CTX *_mem_save_printername_0;
 383         uint32_t _ptr_servername;
 384         TALLOC_CTX *_mem_save_servername_0;
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_align(ndr, 5));
 387                 {
 388                         uint32_t _flags_save_string = ndr->flags;
 389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 391                         if (_ptr_printername) {
 392                                 NDR_PULL_ALLOC(ndr, r->printername);
 393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 394                         } else {
 395                                 r->printername = NULL;
 396                         }
 397                         ndr->flags = _flags_save_string;
 398                 }
 399                 {
 400                         uint32_t _flags_save_string = ndr->flags;
 401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 403                         if (_ptr_servername) {
 404                                 NDR_PULL_ALLOC(ndr, r->servername);
 405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 406                         } else {
 407                                 r->servername = NULL;
 408                         }
 409                         ndr->flags = _flags_save_string;
 410                 }
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 414                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 424                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 426                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 429                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 430                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 433                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 434                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 439         }
 440         if (ndr_flags & NDR_BUFFERS) {
 441                 {
 442                         uint32_t _flags_save_string = ndr->flags;
 443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 444                         if (r->printername) {
 445                                 uint32_t _relative_save_offset;
 446                                 _relative_save_offset = ndr->offset;
 447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 448                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 449                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 452                                 if (ndr->offset > ndr->relative_highest_offset) {
 453                                         ndr->relative_highest_offset = ndr->offset;
 454                                 }
 455                                 ndr->offset = _relative_save_offset;
 456                         }
 457                         ndr->flags = _flags_save_string;
 458                 }
 459                 {
 460                         uint32_t _flags_save_string = ndr->flags;
 461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 462                         if (r->servername) {
 463                                 uint32_t _relative_save_offset;
 464                                 _relative_save_offset = ndr->offset;
 465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 466                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 467                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 470                                 if (ndr->offset > ndr->relative_highest_offset) {
 471                                         ndr->relative_highest_offset = ndr->offset;
 472                                 }
 473                                 ndr->offset = _relative_save_offset;
 474                         }
 475                         ndr->flags = _flags_save_string;
 476                 }
 477         }
 478         return NDR_ERR_SUCCESS;
 479 }
 480
 481 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 482 {
 483         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 484         ndr->depth++;
 485         ndr_print_ptr(ndr, "printername", r->printername);
 486         ndr->depth++;
 487         if (r->printername) {
 488                 ndr_print_string(ndr, "printername", r->printername);
 489         }
 490         ndr->depth--;
 491         ndr_print_ptr(ndr, "servername", r->servername);
 492         ndr->depth++;
 493         if (r->servername) {
 494                 ndr_print_string(ndr, "servername", r->servername);
 495         }
 496         ndr->depth--;
 497         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 498         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 499         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 500         ndr_print_spoolss_Time(ndr, "time", &r->time);
 501         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 502         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 503         ndr_print_uint32(ndr, "version", r->version);
 504         ndr_print_uint32(ndr, "free_build", r->free_build);
 505         ndr_print_uint32(ndr, "spooling", r->spooling);
 506         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 507         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 508         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 509         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 510         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 511         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 512         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 513         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 514         ndr_print_uint32(ndr, "change_id", r->change_id);
 515         ndr_print_WERROR(ndr, "last_error", r->last_error);
 516         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 517         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 518         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 519         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 520         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 521         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 522         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 523         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 524         ndr->depth--;
 525 }
 526
 527 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 528 {
 529         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 530 }
 531
 532 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 533 {
 534         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 535         return NDR_ERR_SUCCESS;
 536 }
 537
 538 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 539 {
 540         uint32_t v;
 541         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 542         *r = v;
 543         return NDR_ERR_SUCCESS;
 544 }
 545
 546 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 547 {
 548         ndr_print_uint32(ndr, name, r);
 549         ndr->depth++;
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 578         ndr->depth--;
 579 }
 580
 581 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 582 {
 583         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 584         return NDR_ERR_SUCCESS;
 585 }
 586
 587 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 588 {
 589         uint16_t v;
 590         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 591         *r = v;
 592         return NDR_ERR_SUCCESS;
 593 }
 594
 595 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 596 {
 597         const char *val = NULL;
 598
 599         switch (r) {
 600                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 601                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 602                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 603         }
 604         ndr_print_enum(ndr, name, "ENUM", val, r);
 605 }
 606
 607 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 608 {
 609         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 610         return NDR_ERR_SUCCESS;
 611 }
 612
 613 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 614 {
 615         uint16_t v;
 616         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 617         *r = v;
 618         return NDR_ERR_SUCCESS;
 619 }
 620
 621 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 622 {
 623         const char *val = NULL;
 624
 625         switch (r) {
 626                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 627                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 628         }
 629         ndr_print_enum(ndr, name, "ENUM", val, r);
 630 }
 631
 632 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 633 {
 634         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 635         return NDR_ERR_SUCCESS;
 636 }
 637
 638 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 639 {
 640         uint16_t v;
 641         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 642         *r = v;
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 647 {
 648         const char *val = NULL;
 649
 650         switch (r) {
 651                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 652                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 653                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 654                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 655                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 656                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 657                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 658                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 659                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 660                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 661                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 662                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 663                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 664                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 665                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 666                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 667                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 668                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 669                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 670                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 671                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 672                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 673                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 674                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 675                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 676                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 677                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 678                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 679                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 680                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 681                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 682                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 683                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 684                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 685                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 686                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 687                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 688                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 689                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 690                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 691                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 692                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 693                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 694                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 695                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 696                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 697                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 698                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 699                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 700                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 701                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 702                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 703                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 704                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 705                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 706                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 707                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 708                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 709                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 710                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 711                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 712                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 713                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 714                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 715                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 716                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 717                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 718                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 719                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 720                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 721                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 722                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 723                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 724                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 725                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 726                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 727                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 728                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 729                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 730                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 731                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 732                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 733                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 734                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 735                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 736                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 737                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 738                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 739                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 740                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 741                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 742         }
 743         ndr_print_enum(ndr, name, "ENUM", val, r);
 744 }
 745
 746 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 747 {
 748         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 749         return NDR_ERR_SUCCESS;
 750 }
 751
 752 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 753 {
 754         uint16_t v;
 755         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 756         *r = v;
 757         return NDR_ERR_SUCCESS;
 758 }
 759
 760 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 761 {
 762         const char *val = NULL;
 763
 764         switch (r) {
 765                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 766                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 767                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 768                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 769                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 770                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 771                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 772                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 773                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 774                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 775                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 776                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 777                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 778         }
 779         ndr_print_enum(ndr, name, "ENUM", val, r);
 780 }
 781
 782 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 783 {
 784         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 785         return NDR_ERR_SUCCESS;
 786 }
 787
 788 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 789 {
 790         uint16_t v;
 791         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 792         *r = v;
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 797 {
 798         const char *val = NULL;
 799
 800         switch (r) {
 801                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 802                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 803                 case DMRES_LOW: val = "DMRES_LOW"; break;
 804                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 805         }
 806         ndr_print_enum(ndr, name, "ENUM", val, r);
 807 }
 808
 809 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 810 {
 811         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 812         return NDR_ERR_SUCCESS;
 813 }
 814
 815 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 816 {
 817         uint16_t v;
 818         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 819         *r = v;
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 824 {
 825         const char *val = NULL;
 826
 827         switch (r) {
 828                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 829                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 830         }
 831         ndr_print_enum(ndr, name, "ENUM", val, r);
 832 }
 833
 834 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 835 {
 836         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 837         return NDR_ERR_SUCCESS;
 838 }
 839
 840 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 841 {
 842         uint16_t v;
 843         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 844         *r = v;
 845         return NDR_ERR_SUCCESS;
 846 }
 847
 848 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 849 {
 850         const char *val = NULL;
 851
 852         switch (r) {
 853                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 854                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 855                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 856         }
 857         ndr_print_enum(ndr, name, "ENUM", val, r);
 858 }
 859
 860 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 861 {
 862         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 863         return NDR_ERR_SUCCESS;
 864 }
 865
 866 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 867 {
 868         uint16_t v;
 869         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 870         *r = v;
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 875 {
 876         const char *val = NULL;
 877
 878         switch (r) {
 879                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 880                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 881                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 882                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 883         }
 884         ndr_print_enum(ndr, name, "ENUM", val, r);
 885 }
 886
 887 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 888 {
 889         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 890         return NDR_ERR_SUCCESS;
 891 }
 892
 893 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 894 {
 895         uint16_t v;
 896         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 897         *r = v;
 898         return NDR_ERR_SUCCESS;
 899 }
 900
 901 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 902 {
 903         const char *val = NULL;
 904
 905         switch (r) {
 906                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 907                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 908         }
 909         ndr_print_enum(ndr, name, "ENUM", val, r);
 910 }
 911
 912 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 913 {
 914         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 915         return NDR_ERR_SUCCESS;
 916 }
 917
 918 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 919 {
 920         uint32_t v;
 921         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 922         *r = v;
 923         return NDR_ERR_SUCCESS;
 924 }
 925
 926 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 927 {
 928         const char *val = NULL;
 929
 930         switch (r) {
 931                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 932                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 933         }
 934         ndr_print_enum(ndr, name, "ENUM", val, r);
 935 }
 936
 937 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 938 {
 939         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 940         return NDR_ERR_SUCCESS;
 941 }
 942
 943 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 944 {
 945         uint32_t v;
 946         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 947         *r = v;
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 952 {
 953         const char *val = NULL;
 954
 955         switch (r) {
 956                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 957                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 958                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 959                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 960         }
 961         ndr_print_enum(ndr, name, "ENUM", val, r);
 962 }
 963
 964 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 965 {
 966         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 967         return NDR_ERR_SUCCESS;
 968 }
 969
 970 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 971 {
 972         uint32_t v;
 973         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 974         *r = v;
 975         return NDR_ERR_SUCCESS;
 976 }
 977
 978 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 979 {
 980         const char *val = NULL;
 981
 982         switch (r) {
 983                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 984                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 985                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 986                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 987         }
 988         ndr_print_enum(ndr, name, "ENUM", val, r);
 989 }
 990
 991 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 992 {
 993         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 994         return NDR_ERR_SUCCESS;
 995 }
 996
 997 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 998 {
 999         uint32_t v;
1000         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1001         *r = v;
1002         return NDR_ERR_SUCCESS;
1003 }
1004
1005 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1006 {
1007         const char *val = NULL;
1008
1009         switch (r) {
1010                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1011                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1012                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1013         }
1014         ndr_print_enum(ndr, name, "ENUM", val, r);
1015 }
1016
1017 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1018 {
1019         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1020         return NDR_ERR_SUCCESS;
1021 }
1022
1023 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1024 {
1025         uint32_t v;
1026         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1027         *r = v;
1028         return NDR_ERR_SUCCESS;
1029 }
1030
1031 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1032 {
1033         const char *val = NULL;
1034
1035         switch (r) {
1036                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1037                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1038                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1039                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1040                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1041                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1042                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1043                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1044                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1045                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1046         }
1047         ndr_print_enum(ndr, name, "ENUM", val, r);
1048 }
1049
1050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1051 {
1052         if (ndr_flags & NDR_SCALARS) {
1053                 NDR_CHECK(ndr_push_align(ndr, 4));
1054                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
1055                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1056                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1057                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1059                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1060                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1062                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1063                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1066                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1067                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1070                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1072                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1073                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
1074                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1078                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1080                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1081                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1082                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1083                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1088                 {
1089                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1091                         {
1092                                 struct ndr_push *_ndr_driverextra_data;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1094                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1096                         }
1097                         ndr->flags = _flags_save_DATA_BLOB;
1098                 }
1099                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1100         }
1101         if (ndr_flags & NDR_BUFFERS) {
1102         }
1103         return NDR_ERR_SUCCESS;
1104 }
1105
1106 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1107 {
1108         if (ndr_flags & NDR_SCALARS) {
1109                 NDR_CHECK(ndr_pull_align(ndr, 4));
1110                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1112                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1113                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1115                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1116                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1118                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1119                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1122                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1123                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1126                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1127                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1128                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1129                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
1130                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1134                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1136                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1137                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1138                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1139                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1144                 {
1145                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1147                         {
1148                                 struct ndr_pull *_ndr_driverextra_data;
1149                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1150                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1151                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1152                         }
1153                         ndr->flags = _flags_save_DATA_BLOB;
1154                 }
1155                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1156         }
1157         if (ndr_flags & NDR_BUFFERS) {
1158         }
1159         return NDR_ERR_SUCCESS;
1160 }
1161
1162 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1163 {
1164         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1165         ndr->depth++;
1166         ndr_print_string(ndr, "devicename", r->devicename);
1167         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1168         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1169         ndr_print_uint16(ndr, "size", r->size);
1170         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1171         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1172         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1173         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1174         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1175         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1176         ndr_print_uint16(ndr, "scale", r->scale);
1177         ndr_print_uint16(ndr, "copies", r->copies);
1178         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1179         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1180         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1181         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1182         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1183         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1184         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1185         ndr_print_string(ndr, "formname", r->formname);
1186         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1187         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1188         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1189         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1190         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1191         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1192         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1193         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1194         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1195         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1196         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1197         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1198         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1199         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1200         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1201         ndr->depth--;
1202 }
1203
1204 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1205 {
1206         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1207 }
1208
1209 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1210 {
1211         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1212         return NDR_ERR_SUCCESS;
1213 }
1214
1215 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1216 {
1217         uint32_t v;
1218         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1219         *r = v;
1220         return NDR_ERR_SUCCESS;
1221 }
1222
1223 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1224 {
1225         ndr_print_uint32(ndr, name, r);
1226         ndr->depth++;
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1246         ndr->depth--;
1247 }
1248
1249 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1250 {
1251         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1252         return NDR_ERR_SUCCESS;
1253 }
1254
1255 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1256 {
1257         uint32_t v;
1258         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1259         *r = v;
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1264 {
1265         ndr_print_uint32(ndr, name, r);
1266         ndr->depth++;
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1283         ndr->depth--;
1284 }
1285
1286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1287 {
1288         if (ndr_flags & NDR_SCALARS) {
1289                 NDR_CHECK(ndr_push_align(ndr, 5));
1290                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1291                 {
1292                         uint32_t _flags_save_string = ndr->flags;
1293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1295                         ndr->flags = _flags_save_string;
1296                 }
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1301                         ndr->flags = _flags_save_string;
1302                 }
1303                 {
1304                         uint32_t _flags_save_string = ndr->flags;
1305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1307                         ndr->flags = _flags_save_string;
1308                 }
1309                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1310         }
1311         if (ndr_flags & NDR_BUFFERS) {
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         if (r->description) {
1316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
1317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1318                         }
1319                         ndr->flags = _flags_save_string;
1320                 }
1321                 {
1322                         uint32_t _flags_save_string = ndr->flags;
1323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1324                         if (r->name) {
1325                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
1326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1327                         }
1328                         ndr->flags = _flags_save_string;
1329                 }
1330                 {
1331                         uint32_t _flags_save_string = ndr->flags;
1332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1333                         if (r->comment) {
1334                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1335                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1336                         }
1337                         ndr->flags = _flags_save_string;
1338                 }
1339         }
1340         return NDR_ERR_SUCCESS;
1341 }
1342
1343 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1344 {
1345         uint32_t _ptr_description;
1346         TALLOC_CTX *_mem_save_description_0;
1347         uint32_t _ptr_name;
1348         TALLOC_CTX *_mem_save_name_0;
1349         uint32_t _ptr_comment;
1350         TALLOC_CTX *_mem_save_comment_0;
1351         if (ndr_flags & NDR_SCALARS) {
1352                 NDR_CHECK(ndr_pull_align(ndr, 5));
1353                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1354                 {
1355                         uint32_t _flags_save_string = ndr->flags;
1356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1357                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1358                         if (_ptr_description) {
1359                                 NDR_PULL_ALLOC(ndr, r->description);
1360                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1361                         } else {
1362                                 r->description = NULL;
1363                         }
1364                         ndr->flags = _flags_save_string;
1365                 }
1366                 {
1367                         uint32_t _flags_save_string = ndr->flags;
1368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1369                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1370                         if (_ptr_name) {
1371                                 NDR_PULL_ALLOC(ndr, r->name);
1372                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1373                         } else {
1374                                 r->name = NULL;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1382                         if (_ptr_comment) {
1383                                 NDR_PULL_ALLOC(ndr, r->comment);
1384                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1385                         } else {
1386                                 r->comment = NULL;
1387                         }
1388                         ndr->flags = _flags_save_string;
1389                 }
1390                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1391         }
1392         if (ndr_flags & NDR_BUFFERS) {
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->description) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1400                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1404                                 if (ndr->offset > ndr->relative_highest_offset) {
1405                                         ndr->relative_highest_offset = ndr->offset;
1406                                 }
1407                                 ndr->offset = _relative_save_offset;
1408                         }
1409                         ndr->flags = _flags_save_string;
1410                 }
1411                 {
1412                         uint32_t _flags_save_string = ndr->flags;
1413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1414                         if (r->name) {
1415                                 uint32_t _relative_save_offset;
1416                                 _relative_save_offset = ndr->offset;
1417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1418                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1419                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1422                                 if (ndr->offset > ndr->relative_highest_offset) {
1423                                         ndr->relative_highest_offset = ndr->offset;
1424                                 }
1425                                 ndr->offset = _relative_save_offset;
1426                         }
1427                         ndr->flags = _flags_save_string;
1428                 }
1429                 {
1430                         uint32_t _flags_save_string = ndr->flags;
1431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1432                         if (r->comment) {
1433                                 uint32_t _relative_save_offset;
1434                                 _relative_save_offset = ndr->offset;
1435                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1436                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1437                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1438                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1439                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1440                                 if (ndr->offset > ndr->relative_highest_offset) {
1441                                         ndr->relative_highest_offset = ndr->offset;
1442                                 }
1443                                 ndr->offset = _relative_save_offset;
1444                         }
1445                         ndr->flags = _flags_save_string;
1446                 }
1447         }
1448         return NDR_ERR_SUCCESS;
1449 }
1450
1451 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1452 {
1453         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1454         ndr->depth++;
1455         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1456         ndr_print_ptr(ndr, "description", r->description);
1457         ndr->depth++;
1458         if (r->description) {
1459                 ndr_print_string(ndr, "description", r->description);
1460         }
1461         ndr->depth--;
1462         ndr_print_ptr(ndr, "name", r->name);
1463         ndr->depth++;
1464         if (r->name) {
1465                 ndr_print_string(ndr, "name", r->name);
1466         }
1467         ndr->depth--;
1468         ndr_print_ptr(ndr, "comment", r->comment);
1469         ndr->depth++;
1470         if (r->comment) {
1471                 ndr_print_string(ndr, "comment", r->comment);
1472         }
1473         ndr->depth--;
1474         ndr->depth--;
1475 }
1476
1477 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1478 {
1479         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1480 }
1481
1482 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1483 {
1484         if (ndr_flags & NDR_SCALARS) {
1485                 NDR_CHECK(ndr_push_align(ndr, 5));
1486                 {
1487                         uint32_t _flags_save_string = ndr->flags;
1488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1490                         ndr->flags = _flags_save_string;
1491                 }
1492                 {
1493                         uint32_t _flags_save_string = ndr->flags;
1494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1502                         ndr->flags = _flags_save_string;
1503                 }
1504                 {
1505                         uint32_t _flags_save_string = ndr->flags;
1506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1508                         ndr->flags = _flags_save_string;
1509                 }
1510                 {
1511                         uint32_t _flags_save_string = ndr->flags;
1512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1514                         ndr->flags = _flags_save_string;
1515                 }
1516                 {
1517                         uint32_t _flags_save_string = ndr->flags;
1518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1520                         ndr->flags = _flags_save_string;
1521                 }
1522                 {
1523                         uint32_t _flags_save_string = ndr->flags;
1524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1526                         ndr->flags = _flags_save_string;
1527                 }
1528                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1529                 {
1530                         uint32_t _flags_save_string = ndr->flags;
1531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1533                         ndr->flags = _flags_save_string;
1534                 }
1535                 {
1536                         uint32_t _flags_save_string = ndr->flags;
1537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1539                         ndr->flags = _flags_save_string;
1540                 }
1541                 {
1542                         uint32_t _flags_save_string = ndr->flags;
1543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 {
1548                         uint32_t _flags_save_string = ndr->flags;
1549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1551                         ndr->flags = _flags_save_string;
1552                 }
1553                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1554                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1559                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1562                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1563         }
1564         if (ndr_flags & NDR_BUFFERS) {
1565                 {
1566                         uint32_t _flags_save_string = ndr->flags;
1567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1568                         if (r->servername) {
1569                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1570                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1571                         }
1572                         ndr->flags = _flags_save_string;
1573                 }
1574                 {
1575                         uint32_t _flags_save_string = ndr->flags;
1576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1577                         if (r->printername) {
1578                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1580                         }
1581                         ndr->flags = _flags_save_string;
1582                 }
1583                 {
1584                         uint32_t _flags_save_string = ndr->flags;
1585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1586                         if (r->sharename) {
1587                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1589                         }
1590                         ndr->flags = _flags_save_string;
1591                 }
1592                 {
1593                         uint32_t _flags_save_string = ndr->flags;
1594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1595                         if (r->portname) {
1596                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1597                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1598                         }
1599                         ndr->flags = _flags_save_string;
1600                 }
1601                 {
1602                         uint32_t _flags_save_string = ndr->flags;
1603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1604                         if (r->drivername) {
1605                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1606                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1607                         }
1608                         ndr->flags = _flags_save_string;
1609                 }
1610                 {
1611                         uint32_t _flags_save_string = ndr->flags;
1612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1613                         if (r->comment) {
1614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1616                         }
1617                         ndr->flags = _flags_save_string;
1618                 }
1619                 {
1620                         uint32_t _flags_save_string = ndr->flags;
1621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1622                         if (r->location) {
1623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1625                         }
1626                         ndr->flags = _flags_save_string;
1627                 }
1628                 if (r->devmode) {
1629                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1630                         {
1631                                 struct ndr_push *_ndr_devmode;
1632                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1633                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1634                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1635                         }
1636                 }
1637                 {
1638                         uint32_t _flags_save_string = ndr->flags;
1639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1640                         if (r->sepfile) {
1641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1643                         }
1644                         ndr->flags = _flags_save_string;
1645                 }
1646                 {
1647                         uint32_t _flags_save_string = ndr->flags;
1648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1649                         if (r->printprocessor) {
1650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1652                         }
1653                         ndr->flags = _flags_save_string;
1654                 }
1655                 {
1656                         uint32_t _flags_save_string = ndr->flags;
1657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1658                         if (r->datatype) {
1659                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1661                         }
1662                         ndr->flags = _flags_save_string;
1663                 }
1664                 {
1665                         uint32_t _flags_save_string = ndr->flags;
1666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1667                         if (r->parameters) {
1668                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1669                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1670                         }
1671                         ndr->flags = _flags_save_string;
1672                 }
1673                 if (r->secdesc) {
1674                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1675                         {
1676                                 struct ndr_push *_ndr_secdesc;
1677                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1678                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1679                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1680                         }
1681                 }
1682         }
1683         return NDR_ERR_SUCCESS;
1684 }
1685
1686 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1687 {
1688         uint32_t _ptr_servername;
1689         TALLOC_CTX *_mem_save_servername_0;
1690         uint32_t _ptr_printername;
1691         TALLOC_CTX *_mem_save_printername_0;
1692         uint32_t _ptr_sharename;
1693         TALLOC_CTX *_mem_save_sharename_0;
1694         uint32_t _ptr_portname;
1695         TALLOC_CTX *_mem_save_portname_0;
1696         uint32_t _ptr_drivername;
1697         TALLOC_CTX *_mem_save_drivername_0;
1698         uint32_t _ptr_comment;
1699         TALLOC_CTX *_mem_save_comment_0;
1700         uint32_t _ptr_location;
1701         TALLOC_CTX *_mem_save_location_0;
1702         uint32_t _ptr_devmode;
1703         TALLOC_CTX *_mem_save_devmode_0;
1704         uint32_t _ptr_sepfile;
1705         TALLOC_CTX *_mem_save_sepfile_0;
1706         uint32_t _ptr_printprocessor;
1707         TALLOC_CTX *_mem_save_printprocessor_0;
1708         uint32_t _ptr_datatype;
1709         TALLOC_CTX *_mem_save_datatype_0;
1710         uint32_t _ptr_parameters;
1711         TALLOC_CTX *_mem_save_parameters_0;
1712         uint32_t _ptr_secdesc;
1713         TALLOC_CTX *_mem_save_secdesc_0;
1714         if (ndr_flags & NDR_SCALARS) {
1715                 NDR_CHECK(ndr_pull_align(ndr, 5));
1716                 {
1717                         uint32_t _flags_save_string = ndr->flags;
1718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1720                         if (_ptr_servername) {
1721                                 NDR_PULL_ALLOC(ndr, r->servername);
1722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1723                         } else {
1724                                 r->servername = NULL;
1725                         }
1726                         ndr->flags = _flags_save_string;
1727                 }
1728                 {
1729                         uint32_t _flags_save_string = ndr->flags;
1730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1732                         if (_ptr_printername) {
1733                                 NDR_PULL_ALLOC(ndr, r->printername);
1734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1735                         } else {
1736                                 r->printername = NULL;
1737                         }
1738                         ndr->flags = _flags_save_string;
1739                 }
1740                 {
1741                         uint32_t _flags_save_string = ndr->flags;
1742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1744                         if (_ptr_sharename) {
1745                                 NDR_PULL_ALLOC(ndr, r->sharename);
1746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1747                         } else {
1748                                 r->sharename = NULL;
1749                         }
1750                         ndr->flags = _flags_save_string;
1751                 }
1752                 {
1753                         uint32_t _flags_save_string = ndr->flags;
1754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1756                         if (_ptr_portname) {
1757                                 NDR_PULL_ALLOC(ndr, r->portname);
1758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1759                         } else {
1760                                 r->portname = NULL;
1761                         }
1762                         ndr->flags = _flags_save_string;
1763                 }
1764                 {
1765                         uint32_t _flags_save_string = ndr->flags;
1766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1768                         if (_ptr_drivername) {
1769                                 NDR_PULL_ALLOC(ndr, r->drivername);
1770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1771                         } else {
1772                                 r->drivername = NULL;
1773                         }
1774                         ndr->flags = _flags_save_string;
1775                 }
1776                 {
1777                         uint32_t _flags_save_string = ndr->flags;
1778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1780                         if (_ptr_comment) {
1781                                 NDR_PULL_ALLOC(ndr, r->comment);
1782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1783                         } else {
1784                                 r->comment = NULL;
1785                         }
1786                         ndr->flags = _flags_save_string;
1787                 }
1788                 {
1789                         uint32_t _flags_save_string = ndr->flags;
1790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1792                         if (_ptr_location) {
1793                                 NDR_PULL_ALLOC(ndr, r->location);
1794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1795                         } else {
1796                                 r->location = NULL;
1797                         }
1798                         ndr->flags = _flags_save_string;
1799                 }
1800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1801                 if (_ptr_devmode) {
1802                         NDR_PULL_ALLOC(ndr, r->devmode);
1803                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1804                 } else {
1805                         r->devmode = NULL;
1806                 }
1807                 {
1808                         uint32_t _flags_save_string = ndr->flags;
1809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1811                         if (_ptr_sepfile) {
1812                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1814                         } else {
1815                                 r->sepfile = NULL;
1816                         }
1817                         ndr->flags = _flags_save_string;
1818                 }
1819                 {
1820                         uint32_t _flags_save_string = ndr->flags;
1821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1822                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1823                         if (_ptr_printprocessor) {
1824                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1825                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1826                         } else {
1827                                 r->printprocessor = NULL;
1828                         }
1829                         ndr->flags = _flags_save_string;
1830                 }
1831                 {
1832                         uint32_t _flags_save_string = ndr->flags;
1833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1834                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1835                         if (_ptr_datatype) {
1836                                 NDR_PULL_ALLOC(ndr, r->datatype);
1837                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1838                         } else {
1839                                 r->datatype = NULL;
1840                         }
1841                         ndr->flags = _flags_save_string;
1842                 }
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1847                         if (_ptr_parameters) {
1848                                 NDR_PULL_ALLOC(ndr, r->parameters);
1849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1850                         } else {
1851                                 r->parameters = NULL;
1852                         }
1853                         ndr->flags = _flags_save_string;
1854                 }
1855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1856                 if (_ptr_secdesc) {
1857                         NDR_PULL_ALLOC(ndr, r->secdesc);
1858                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1859                 } else {
1860                         r->secdesc = NULL;
1861                 }
1862                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1864                 if (r->priority > 99) {
1865                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1866                 }
1867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1870                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1873                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1874         }
1875         if (ndr_flags & NDR_BUFFERS) {
1876                 {
1877                         uint32_t _flags_save_string = ndr->flags;
1878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1879                         if (r->servername) {
1880                                 uint32_t _relative_save_offset;
1881                                 _relative_save_offset = ndr->offset;
1882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1883                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1884                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1887                                 if (ndr->offset > ndr->relative_highest_offset) {
1888                                         ndr->relative_highest_offset = ndr->offset;
1889                                 }
1890                                 ndr->offset = _relative_save_offset;
1891                         }
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         if (r->printername) {
1898                                 uint32_t _relative_save_offset;
1899                                 _relative_save_offset = ndr->offset;
1900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1901                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1902                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1905                                 if (ndr->offset > ndr->relative_highest_offset) {
1906                                         ndr->relative_highest_offset = ndr->offset;
1907                                 }
1908                                 ndr->offset = _relative_save_offset;
1909                         }
1910                         ndr->flags = _flags_save_string;
1911                 }
1912                 {
1913                         uint32_t _flags_save_string = ndr->flags;
1914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1915                         if (r->sharename) {
1916                                 uint32_t _relative_save_offset;
1917                                 _relative_save_offset = ndr->offset;
1918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1919                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1920                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1923                                 if (ndr->offset > ndr->relative_highest_offset) {
1924                                         ndr->relative_highest_offset = ndr->offset;
1925                                 }
1926                                 ndr->offset = _relative_save_offset;
1927                         }
1928                         ndr->flags = _flags_save_string;
1929                 }
1930                 {
1931                         uint32_t _flags_save_string = ndr->flags;
1932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1933                         if (r->portname) {
1934                                 uint32_t _relative_save_offset;
1935                                 _relative_save_offset = ndr->offset;
1936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1937                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1938                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1941                                 if (ndr->offset > ndr->relative_highest_offset) {
1942                                         ndr->relative_highest_offset = ndr->offset;
1943                                 }
1944                                 ndr->offset = _relative_save_offset;
1945                         }
1946                         ndr->flags = _flags_save_string;
1947                 }
1948                 {
1949                         uint32_t _flags_save_string = ndr->flags;
1950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1951                         if (r->drivername) {
1952                                 uint32_t _relative_save_offset;
1953                                 _relative_save_offset = ndr->offset;
1954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1955                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1956                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1959                                 if (ndr->offset > ndr->relative_highest_offset) {
1960                                         ndr->relative_highest_offset = ndr->offset;
1961                                 }
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966                 {
1967                         uint32_t _flags_save_string = ndr->flags;
1968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1969                         if (r->comment) {
1970                                 uint32_t _relative_save_offset;
1971                                 _relative_save_offset = ndr->offset;
1972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1973                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1974                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1977                                 if (ndr->offset > ndr->relative_highest_offset) {
1978                                         ndr->relative_highest_offset = ndr->offset;
1979                                 }
1980                                 ndr->offset = _relative_save_offset;
1981                         }
1982                         ndr->flags = _flags_save_string;
1983                 }
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->location) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1991                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1995                                 if (ndr->offset > ndr->relative_highest_offset) {
1996                                         ndr->relative_highest_offset = ndr->offset;
1997                                 }
1998                                 ndr->offset = _relative_save_offset;
1999                         }
2000                         ndr->flags = _flags_save_string;
2001                 }
2002                 if (r->devmode) {
2003                         uint32_t _relative_save_offset;
2004                         _relative_save_offset = ndr->offset;
2005                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2006                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2007                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2008                         {
2009                                 struct ndr_pull *_ndr_devmode;
2010                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2011                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2012                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2013                         }
2014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2015                         if (ndr->offset > ndr->relative_highest_offset) {
2016                                 ndr->relative_highest_offset = ndr->offset;
2017                         }
2018                         ndr->offset = _relative_save_offset;
2019                 }
2020                 {
2021                         uint32_t _flags_save_string = ndr->flags;
2022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2023                         if (r->sepfile) {
2024                                 uint32_t _relative_save_offset;
2025                                 _relative_save_offset = ndr->offset;
2026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
2027                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
2028                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
2029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
2030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
2031                                 if (ndr->offset > ndr->relative_highest_offset) {
2032                                         ndr->relative_highest_offset = ndr->offset;
2033                                 }
2034                                 ndr->offset = _relative_save_offset;
2035                         }
2036                         ndr->flags = _flags_save_string;
2037                 }
2038                 {
2039                         uint32_t _flags_save_string = ndr->flags;
2040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2041                         if (r->printprocessor) {
2042                                 uint32_t _relative_save_offset;
2043                                 _relative_save_offset = ndr->offset;
2044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2045                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2046                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2049                                 if (ndr->offset > ndr->relative_highest_offset) {
2050                                         ndr->relative_highest_offset = ndr->offset;
2051                                 }
2052                                 ndr->offset = _relative_save_offset;
2053                         }
2054                         ndr->flags = _flags_save_string;
2055                 }
2056                 {
2057                         uint32_t _flags_save_string = ndr->flags;
2058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2059                         if (r->datatype) {
2060                                 uint32_t _relative_save_offset;
2061                                 _relative_save_offset = ndr->offset;
2062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2063                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2064                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2067                                 if (ndr->offset > ndr->relative_highest_offset) {
2068                                         ndr->relative_highest_offset = ndr->offset;
2069                                 }
2070                                 ndr->offset = _relative_save_offset;
2071                         }
2072                         ndr->flags = _flags_save_string;
2073                 }
2074                 {
2075                         uint32_t _flags_save_string = ndr->flags;
2076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2077                         if (r->parameters) {
2078                                 uint32_t _relative_save_offset;
2079                                 _relative_save_offset = ndr->offset;
2080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2081                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2082                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2085                                 if (ndr->offset > ndr->relative_highest_offset) {
2086                                         ndr->relative_highest_offset = ndr->offset;
2087                                 }
2088                                 ndr->offset = _relative_save_offset;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 if (r->secdesc) {
2093                         uint32_t _relative_save_offset;
2094                         _relative_save_offset = ndr->offset;
2095                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2096                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2097                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2098                         {
2099                                 struct ndr_pull *_ndr_secdesc;
2100                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2101                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2102                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2103                         }
2104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2105                         if (ndr->offset > ndr->relative_highest_offset) {
2106                                 ndr->relative_highest_offset = ndr->offset;
2107                         }
2108                         ndr->offset = _relative_save_offset;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "servername", r->servername);
2119         ndr->depth++;
2120         if (r->servername) {
2121                 ndr_print_string(ndr, "servername", r->servername);
2122         }
2123         ndr->depth--;
2124         ndr_print_ptr(ndr, "printername", r->printername);
2125         ndr->depth++;
2126         if (r->printername) {
2127                 ndr_print_string(ndr, "printername", r->printername);
2128         }
2129         ndr->depth--;
2130         ndr_print_ptr(ndr, "sharename", r->sharename);
2131         ndr->depth++;
2132         if (r->sharename) {
2133                 ndr_print_string(ndr, "sharename", r->sharename);
2134         }
2135         ndr->depth--;
2136         ndr_print_ptr(ndr, "portname", r->portname);
2137         ndr->depth++;
2138         if (r->portname) {
2139                 ndr_print_string(ndr, "portname", r->portname);
2140         }
2141         ndr->depth--;
2142         ndr_print_ptr(ndr, "drivername", r->drivername);
2143         ndr->depth++;
2144         if (r->drivername) {
2145                 ndr_print_string(ndr, "drivername", r->drivername);
2146         }
2147         ndr->depth--;
2148         ndr_print_ptr(ndr, "comment", r->comment);
2149         ndr->depth++;
2150         if (r->comment) {
2151                 ndr_print_string(ndr, "comment", r->comment);
2152         }
2153         ndr->depth--;
2154         ndr_print_ptr(ndr, "location", r->location);
2155         ndr->depth++;
2156         if (r->location) {
2157                 ndr_print_string(ndr, "location", r->location);
2158         }
2159         ndr->depth--;
2160         ndr_print_ptr(ndr, "devmode", r->devmode);
2161         ndr->depth++;
2162         if (r->devmode) {
2163                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2164         }
2165         ndr->depth--;
2166         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2167         ndr->depth++;
2168         if (r->sepfile) {
2169                 ndr_print_string(ndr, "sepfile", r->sepfile);
2170         }
2171         ndr->depth--;
2172         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2173         ndr->depth++;
2174         if (r->printprocessor) {
2175                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2176         }
2177         ndr->depth--;
2178         ndr_print_ptr(ndr, "datatype", r->datatype);
2179         ndr->depth++;
2180         if (r->datatype) {
2181                 ndr_print_string(ndr, "datatype", r->datatype);
2182         }
2183         ndr->depth--;
2184         ndr_print_ptr(ndr, "parameters", r->parameters);
2185         ndr->depth++;
2186         if (r->parameters) {
2187                 ndr_print_string(ndr, "parameters", r->parameters);
2188         }
2189         ndr->depth--;
2190         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2191         ndr->depth++;
2192         if (r->secdesc) {
2193                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2194         }
2195         ndr->depth--;
2196         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2197         ndr_print_uint32(ndr, "priority", r->priority);
2198         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2199         ndr_print_uint32(ndr, "starttime", r->starttime);
2200         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2201         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2202         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2203         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2204         ndr->depth--;
2205 }
2206
2207 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2208 {
2209         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2210 }
2211
2212 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2213 {
2214         if (ndr_flags & NDR_SCALARS) {
2215                 NDR_CHECK(ndr_push_align(ndr, 5));
2216                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2217                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2218         }
2219         if (ndr_flags & NDR_BUFFERS) {
2220                 if (r->secdesc) {
2221                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
2222                         {
2223                                 struct ndr_push *_ndr_secdesc;
2224                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2225                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2226                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2227                         }
2228                 }
2229         }
2230         return NDR_ERR_SUCCESS;
2231 }
2232
2233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2234 {
2235         uint32_t _ptr_secdesc;
2236         TALLOC_CTX *_mem_save_secdesc_0;
2237         if (ndr_flags & NDR_SCALARS) {
2238                 NDR_CHECK(ndr_pull_align(ndr, 5));
2239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2240                 if (_ptr_secdesc) {
2241                         NDR_PULL_ALLOC(ndr, r->secdesc);
2242                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2243                 } else {
2244                         r->secdesc = NULL;
2245                 }
2246                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2247         }
2248         if (ndr_flags & NDR_BUFFERS) {
2249                 if (r->secdesc) {
2250                         uint32_t _relative_save_offset;
2251                         _relative_save_offset = ndr->offset;
2252                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2253                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2254                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2255                         {
2256                                 struct ndr_pull *_ndr_secdesc;
2257                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2258                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2259                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2260                         }
2261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2262                         if (ndr->offset > ndr->relative_highest_offset) {
2263                                 ndr->relative_highest_offset = ndr->offset;
2264                         }
2265                         ndr->offset = _relative_save_offset;
2266                 }
2267         }
2268         return NDR_ERR_SUCCESS;
2269 }
2270
2271 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2272 {
2273         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2274         ndr->depth++;
2275         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2276         ndr->depth++;
2277         if (r->secdesc) {
2278                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2279         }
2280         ndr->depth--;
2281         ndr->depth--;
2282 }
2283
2284 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2285 {
2286         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2287 }
2288
2289 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2290 {
2291         if (ndr_flags & NDR_SCALARS) {
2292                 NDR_CHECK(ndr_push_align(ndr, 5));
2293                 {
2294                         uint32_t _flags_save_string = ndr->flags;
2295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2297                         ndr->flags = _flags_save_string;
2298                 }
2299                 {
2300                         uint32_t _flags_save_string = ndr->flags;
2301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2303                         ndr->flags = _flags_save_string;
2304                 }
2305                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2306                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2307         }
2308         if (ndr_flags & NDR_BUFFERS) {
2309                 {
2310                         uint32_t _flags_save_string = ndr->flags;
2311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2312                         if (r->printername) {
2313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2315                         }
2316                         ndr->flags = _flags_save_string;
2317                 }
2318                 {
2319                         uint32_t _flags_save_string = ndr->flags;
2320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2321                         if (r->servername) {
2322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
2323                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2324                         }
2325                         ndr->flags = _flags_save_string;
2326                 }
2327         }
2328         return NDR_ERR_SUCCESS;
2329 }
2330
2331 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2332 {
2333         uint32_t _ptr_printername;
2334         TALLOC_CTX *_mem_save_printername_0;
2335         uint32_t _ptr_servername;
2336         TALLOC_CTX *_mem_save_servername_0;
2337         if (ndr_flags & NDR_SCALARS) {
2338                 NDR_CHECK(ndr_pull_align(ndr, 5));
2339                 {
2340                         uint32_t _flags_save_string = ndr->flags;
2341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2343                         if (_ptr_printername) {
2344                                 NDR_PULL_ALLOC(ndr, r->printername);
2345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2346                         } else {
2347                                 r->printername = NULL;
2348                         }
2349                         ndr->flags = _flags_save_string;
2350                 }
2351                 {
2352                         uint32_t _flags_save_string = ndr->flags;
2353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2355                         if (_ptr_servername) {
2356                                 NDR_PULL_ALLOC(ndr, r->servername);
2357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2358                         } else {
2359                                 r->servername = NULL;
2360                         }
2361                         ndr->flags = _flags_save_string;
2362                 }
2363                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2364                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2365         }
2366         if (ndr_flags & NDR_BUFFERS) {
2367                 {
2368                         uint32_t _flags_save_string = ndr->flags;
2369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2370                         if (r->printername) {
2371                                 uint32_t _relative_save_offset;
2372                                 _relative_save_offset = ndr->offset;
2373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2374                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2375                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2378                                 if (ndr->offset > ndr->relative_highest_offset) {
2379                                         ndr->relative_highest_offset = ndr->offset;
2380                                 }
2381                                 ndr->offset = _relative_save_offset;
2382                         }
2383                         ndr->flags = _flags_save_string;
2384                 }
2385                 {
2386                         uint32_t _flags_save_string = ndr->flags;
2387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2388                         if (r->servername) {
2389                                 uint32_t _relative_save_offset;
2390                                 _relative_save_offset = ndr->offset;
2391                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2392                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2393                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2394                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2395                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2396                                 if (ndr->offset > ndr->relative_highest_offset) {
2397                                         ndr->relative_highest_offset = ndr->offset;
2398                                 }
2399                                 ndr->offset = _relative_save_offset;
2400                         }
2401                         ndr->flags = _flags_save_string;
2402                 }
2403         }
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2408 {
2409         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2410         ndr->depth++;
2411         ndr_print_ptr(ndr, "printername", r->printername);
2412         ndr->depth++;
2413         if (r->printername) {
2414                 ndr_print_string(ndr, "printername", r->printername);
2415         }
2416         ndr->depth--;
2417         ndr_print_ptr(ndr, "servername", r->servername);
2418         ndr->depth++;
2419         if (r->servername) {
2420                 ndr_print_string(ndr, "servername", r->servername);
2421         }
2422         ndr->depth--;
2423         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2424         ndr->depth--;
2425 }
2426
2427 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2428 {
2429         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2430 }
2431
2432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2433 {
2434         if (ndr_flags & NDR_SCALARS) {
2435                 NDR_CHECK(ndr_push_align(ndr, 5));
2436                 {
2437                         uint32_t _flags_save_string = ndr->flags;
2438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2440                         ndr->flags = _flags_save_string;
2441                 }
2442                 {
2443                         uint32_t _flags_save_string = ndr->flags;
2444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2445                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2446                         ndr->flags = _flags_save_string;
2447                 }
2448                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2451                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2452         }
2453         if (ndr_flags & NDR_BUFFERS) {
2454                 {
2455                         uint32_t _flags_save_string = ndr->flags;
2456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2457                         if (r->printername) {
2458                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2459                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2460                         }
2461                         ndr->flags = _flags_save_string;
2462                 }
2463                 {
2464                         uint32_t _flags_save_string = ndr->flags;
2465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2466                         if (r->portname) {
2467                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
2468                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2469                         }
2470                         ndr->flags = _flags_save_string;
2471                 }
2472         }
2473         return NDR_ERR_SUCCESS;
2474 }
2475
2476 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2477 {
2478         uint32_t _ptr_printername;
2479         TALLOC_CTX *_mem_save_printername_0;
2480         uint32_t _ptr_portname;
2481         TALLOC_CTX *_mem_save_portname_0;
2482         if (ndr_flags & NDR_SCALARS) {
2483                 NDR_CHECK(ndr_pull_align(ndr, 5));
2484                 {
2485                         uint32_t _flags_save_string = ndr->flags;
2486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2487                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2488                         if (_ptr_printername) {
2489                                 NDR_PULL_ALLOC(ndr, r->printername);
2490                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2491                         } else {
2492                                 r->printername = NULL;
2493                         }
2494                         ndr->flags = _flags_save_string;
2495                 }
2496                 {
2497                         uint32_t _flags_save_string = ndr->flags;
2498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2499                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2500                         if (_ptr_portname) {
2501                                 NDR_PULL_ALLOC(ndr, r->portname);
2502                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2503                         } else {
2504                                 r->portname = NULL;
2505                         }
2506                         ndr->flags = _flags_save_string;
2507                 }
2508                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2512         }
2513         if (ndr_flags & NDR_BUFFERS) {
2514                 {
2515                         uint32_t _flags_save_string = ndr->flags;
2516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2517                         if (r->printername) {
2518                                 uint32_t _relative_save_offset;
2519                                 _relative_save_offset = ndr->offset;
2520                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2521                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2522                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2523                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2524                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2525                                 if (ndr->offset > ndr->relative_highest_offset) {
2526                                         ndr->relative_highest_offset = ndr->offset;
2527                                 }
2528                                 ndr->offset = _relative_save_offset;
2529                         }
2530                         ndr->flags = _flags_save_string;
2531                 }
2532                 {
2533                         uint32_t _flags_save_string = ndr->flags;
2534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2535                         if (r->portname) {
2536                                 uint32_t _relative_save_offset;
2537                                 _relative_save_offset = ndr->offset;
2538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2539                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2540                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2543                                 if (ndr->offset > ndr->relative_highest_offset) {
2544                                         ndr->relative_highest_offset = ndr->offset;
2545                                 }
2546                                 ndr->offset = _relative_save_offset;
2547                         }
2548                         ndr->flags = _flags_save_string;
2549                 }
2550         }
2551         return NDR_ERR_SUCCESS;
2552 }
2553
2554 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2555 {
2556         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2557         ndr->depth++;
2558         ndr_print_ptr(ndr, "printername", r->printername);
2559         ndr->depth++;
2560         if (r->printername) {
2561                 ndr_print_string(ndr, "printername", r->printername);
2562         }
2563         ndr->depth--;
2564         ndr_print_ptr(ndr, "portname", r->portname);
2565         ndr->depth++;
2566         if (r->portname) {
2567                 ndr_print_string(ndr, "portname", r->portname);
2568         }
2569         ndr->depth--;
2570         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2571         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2572         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2573         ndr->depth--;
2574 }
2575
2576 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2577 {
2578         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2579 }
2580
2581 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2582 {
2583         if (ndr_flags & NDR_SCALARS) {
2584                 NDR_CHECK(ndr_push_align(ndr, 4));
2585                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2586                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2587         }
2588         if (ndr_flags & NDR_BUFFERS) {
2589         }
2590         return NDR_ERR_SUCCESS;
2591 }
2592
2593 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2594 {
2595         if (ndr_flags & NDR_SCALARS) {
2596                 NDR_CHECK(ndr_pull_align(ndr, 4));
2597                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2598                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2599         }
2600         if (ndr_flags & NDR_BUFFERS) {
2601         }
2602         return NDR_ERR_SUCCESS;
2603 }
2604
2605 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2606 {
2607         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2608         ndr->depth++;
2609         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2610         ndr->depth--;
2611 }
2612
2613 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2614 {
2615         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2616 }
2617
2618 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2619 {
2620         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2621         return NDR_ERR_SUCCESS;
2622 }
2623
2624 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2625 {
2626         uint32_t v;
2627         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2628         *r = v;
2629         return NDR_ERR_SUCCESS;
2630 }
2631
2632 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2633 {
2634         ndr_print_uint32(ndr, name, r);
2635         ndr->depth++;
2636         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2637         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2638         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2639         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2640         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2641         ndr->depth--;
2642 }
2643
2644 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2645 {
2646         if (ndr_flags & NDR_SCALARS) {
2647                 NDR_CHECK(ndr_push_align(ndr, 5));
2648                 {
2649                         uint32_t _flags_save_string = ndr->flags;
2650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2652                         ndr->flags = _flags_save_string;
2653                 }
2654                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2655                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2656         }
2657         if (ndr_flags & NDR_BUFFERS) {
2658                 {
2659                         uint32_t _flags_save_string = ndr->flags;
2660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2661                         if (r->guid) {
2662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2664                         }
2665                         ndr->flags = _flags_save_string;
2666                 }
2667         }
2668         return NDR_ERR_SUCCESS;
2669 }
2670
2671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2672 {
2673         uint32_t _ptr_guid;
2674         TALLOC_CTX *_mem_save_guid_0;
2675         if (ndr_flags & NDR_SCALARS) {
2676                 NDR_CHECK(ndr_pull_align(ndr, 5));
2677                 {
2678                         uint32_t _flags_save_string = ndr->flags;
2679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2681                         if (_ptr_guid) {
2682                                 NDR_PULL_ALLOC(ndr, r->guid);
2683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2684                         } else {
2685                                 r->guid = NULL;
2686                         }
2687                         ndr->flags = _flags_save_string;
2688                 }
2689                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2690                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2691         }
2692         if (ndr_flags & NDR_BUFFERS) {
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         if (r->guid) {
2697                                 uint32_t _relative_save_offset;
2698                                 _relative_save_offset = ndr->offset;
2699                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2700                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2701                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2702                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2703                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2704                                 if (ndr->offset > ndr->relative_highest_offset) {
2705                                         ndr->relative_highest_offset = ndr->offset;
2706                                 }
2707                                 ndr->offset = _relative_save_offset;
2708                         }
2709                         ndr->flags = _flags_save_string;
2710                 }
2711         }
2712         return NDR_ERR_SUCCESS;
2713 }
2714
2715 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2716 {
2717         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2718         ndr->depth++;
2719         ndr_print_ptr(ndr, "guid", r->guid);
2720         ndr->depth++;
2721         if (r->guid) {
2722                 ndr_print_string(ndr, "guid", r->guid);
2723         }
2724         ndr->depth--;
2725         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2726         ndr->depth--;
2727 }
2728
2729 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2730 {
2731         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2732 }
2733
2734 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2735 {
2736         if (ndr_flags & NDR_SCALARS) {
2737                 NDR_CHECK(ndr_push_align(ndr, 5));
2738                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2739                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2740         }
2741         if (ndr_flags & NDR_BUFFERS) {
2742                 if (r->devmode) {
2743                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2744                         {
2745                                 struct ndr_push *_ndr_devmode;
2746                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2747                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2748                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2749                         }
2750                 }
2751         }
2752         return NDR_ERR_SUCCESS;
2753 }
2754
2755 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2756 {
2757         uint32_t _ptr_devmode;
2758         TALLOC_CTX *_mem_save_devmode_0;
2759         if (ndr_flags & NDR_SCALARS) {
2760                 NDR_CHECK(ndr_pull_align(ndr, 5));
2761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2762                 if (_ptr_devmode) {
2763                         NDR_PULL_ALLOC(ndr, r->devmode);
2764                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2765                 } else {
2766                         r->devmode = NULL;
2767                 }
2768                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2769         }
2770         if (ndr_flags & NDR_BUFFERS) {
2771                 if (r->devmode) {
2772                         uint32_t _relative_save_offset;
2773                         _relative_save_offset = ndr->offset;
2774                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2775                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2776                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2777                         {
2778                                 struct ndr_pull *_ndr_devmode;
2779                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2780                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2781                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2782                         }
2783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2784                         if (ndr->offset > ndr->relative_highest_offset) {
2785                                 ndr->relative_highest_offset = ndr->offset;
2786                         }
2787                         ndr->offset = _relative_save_offset;
2788                 }
2789         }
2790         return NDR_ERR_SUCCESS;
2791 }
2792
2793 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2794 {
2795         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2796         ndr->depth++;
2797         ndr_print_ptr(ndr, "devmode", r->devmode);
2798         ndr->depth++;
2799         if (r->devmode) {
2800                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2801         }
2802         ndr->depth--;
2803         ndr->depth--;
2804 }
2805
2806 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2807 {
2808         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2809         if (ndr_flags & NDR_SCALARS) {
2810                 int level = ndr_push_get_switch_value(ndr, r);
2811                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2812                 switch (level) {
2813                         case 0: {
2814                                 NDR_CHECK(ndr_push_align(ndr, 5));
2815                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2816                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2817                         break; }
2818
2819                         case 1: {
2820                                 NDR_CHECK(ndr_push_align(ndr, 5));
2821                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2822                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2823                         break; }
2824
2825                         case 2: {
2826                                 NDR_CHECK(ndr_push_align(ndr, 5));
2827                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2828                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2829                         break; }
2830
2831                         case 3: {
2832                                 NDR_CHECK(ndr_push_align(ndr, 5));
2833                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2834                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2835                         break; }
2836
2837                         case 4: {
2838                                 NDR_CHECK(ndr_push_align(ndr, 5));
2839                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2840                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2841                         break; }
2842
2843                         case 5: {
2844                                 NDR_CHECK(ndr_push_align(ndr, 5));
2845                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2846                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2847                         break; }
2848
2849                         case 6: {
2850                                 NDR_CHECK(ndr_push_align(ndr, 4));
2851                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2852                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2853                         break; }
2854
2855                         case 7: {
2856                                 NDR_CHECK(ndr_push_align(ndr, 5));
2857                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2858                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2859                         break; }
2860
2861                         case 8: {
2862                                 NDR_CHECK(ndr_push_align(ndr, 5));
2863                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2864                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2865                         break; }
2866
2867                         case 9: {
2868                                 NDR_CHECK(ndr_push_align(ndr, 5));
2869                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2870                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2871                         break; }
2872
2873                         default: {
2874                         break; }
2875
2876                 }
2877         }
2878         if (ndr_flags & NDR_BUFFERS) {
2879                 int level = ndr_push_get_switch_value(ndr, r);
2880                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2881                 switch (level) {
2882                         case 0:
2883                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2884                         break;
2885
2886                         case 1:
2887                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2888                         break;
2889
2890                         case 2:
2891                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2892                         break;
2893
2894                         case 3:
2895                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2896                         break;
2897
2898                         case 4:
2899                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2900                         break;
2901
2902                         case 5:
2903                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2904                         break;
2905
2906                         case 6:
2907                         break;
2908
2909                         case 7:
2910                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2911                         break;
2912
2913                         case 8:
2914                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2915                         break;
2916
2917                         case 9:
2918                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2919                         break;
2920
2921                         default:
2922                         break;
2923
2924                 }
2925         }
2926         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2927         return NDR_ERR_SUCCESS;
2928 }
2929
2930 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2931 {
2932         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2933         int level;
2934         level = ndr_pull_get_switch_value(ndr, r);
2935         if (ndr_flags & NDR_SCALARS) {
2936                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2937                 switch (level) {
2938                         case 0: {
2939                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2940                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2941                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2942                         break; }
2943
2944                         case 1: {
2945                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2946                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2947                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2948                         break; }
2949
2950                         case 2: {
2951                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2952                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2953                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2954                         break; }
2955
2956                         case 3: {
2957                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2958                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2959                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2960                         break; }
2961
2962                         case 4: {
2963                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2964                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2965                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2966                         break; }
2967
2968                         case 5: {
2969                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2970                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2971                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2972                         break; }
2973
2974                         case 6: {
2975                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2976                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2977                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2978                         break; }
2979
2980                         case 7: {
2981                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2982                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2983                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2984                         break; }
2985
2986                         case 8: {
2987                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2988                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2989                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2990                         break; }
2991
2992                         case 9: {
2993                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2994                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2995                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2996                         break; }
2997
2998                         default: {
2999                         break; }
3000
3001                 }
3002         }
3003         if (ndr_flags & NDR_BUFFERS) {
3004                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
3005                 switch (level) {
3006                         case 0:
3007                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3008                         break;
3009
3010                         case 1:
3011                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3012                         break;
3013
3014                         case 2:
3015                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3016                         break;
3017
3018                         case 3:
3019                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3020                         break;
3021
3022                         case 4:
3023                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3024                         break;
3025
3026                         case 5:
3027                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3028                         break;
3029
3030                         case 6:
3031                         break;
3032
3033                         case 7:
3034                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3035                         break;
3036
3037                         case 8:
3038                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3039                         break;
3040
3041                         case 9:
3042                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3043                         break;
3044
3045                         default:
3046                         break;
3047
3048                 }
3049         }
3050         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
3051         return NDR_ERR_SUCCESS;
3052 }
3053
3054 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
3055 {
3056         int level;
3057         level = ndr_print_get_switch_value(ndr, r);
3058         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
3059         switch (level) {
3060                 case 0:
3061                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
3062                 break;
3063
3064                 case 1:
3065                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
3066                 break;
3067
3068                 case 2:
3069                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
3070                 break;
3071
3072                 case 3:
3073                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
3074                 break;
3075
3076                 case 4:
3077                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3078                 break;
3079
3080                 case 5:
3081                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3082                 break;
3083
3084                 case 6:
3085                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3086                 break;
3087
3088                 case 7:
3089                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3090                 break;
3091
3092                 case 8:
3093                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3094                 break;
3095
3096                 case 9:
3097                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3098                 break;
3099
3100                 default:
3101                 break;
3102
3103         }
3104 }
3105
3106 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3107 {
3108         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3109 }
3110
3111 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3112 {
3113         if (ndr_flags & NDR_SCALARS) {
3114                 NDR_CHECK(ndr_push_align(ndr, 5));
3115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3117                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3118         }
3119         if (ndr_flags & NDR_BUFFERS) {
3120                 if (r->devmode) {
3121                         {
3122                                 struct ndr_push *_ndr_devmode;
3123                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3124                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3125                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3126                         }
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3133 {
3134         uint32_t _ptr_devmode;
3135         TALLOC_CTX *_mem_save_devmode_0;
3136         if (ndr_flags & NDR_SCALARS) {
3137                 NDR_CHECK(ndr_pull_align(ndr, 5));
3138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3140                 if (_ptr_devmode) {
3141                         NDR_PULL_ALLOC(ndr, r->devmode);
3142                 } else {
3143                         r->devmode = NULL;
3144                 }
3145                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3146         }
3147         if (ndr_flags & NDR_BUFFERS) {
3148                 if (r->devmode) {
3149                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3150                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3151                         {
3152                                 struct ndr_pull *_ndr_devmode;
3153                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3154                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3155                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3156                         }
3157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3158                 }
3159         }
3160         return NDR_ERR_SUCCESS;
3161 }
3162
3163 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3164 {
3165         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3166         ndr->depth++;
3167         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
3168         ndr_print_ptr(ndr, "devmode", r->devmode);
3169         ndr->depth++;
3170         if (r->devmode) {
3171                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3172         }
3173         ndr->depth--;
3174         ndr->depth--;
3175 }
3176
3177 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3178 {
3179         if (ndr_flags & NDR_SCALARS) {
3180                 NDR_CHECK(ndr_push_align(ndr, 5));
3181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3182                 {
3183                         uint32_t _flags_save_string = ndr->flags;
3184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3185                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3186                         ndr->flags = _flags_save_string;
3187                 }
3188                 {
3189                         uint32_t _flags_save_string = ndr->flags;
3190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3191                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3192                         ndr->flags = _flags_save_string;
3193                 }
3194                 {
3195                         uint32_t _flags_save_string = ndr->flags;
3196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3198                         ndr->flags = _flags_save_string;
3199                 }
3200                 {
3201                         uint32_t _flags_save_string = ndr->flags;
3202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3204                         ndr->flags = _flags_save_string;
3205                 }
3206                 {
3207                         uint32_t _flags_save_string = ndr->flags;
3208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3210                         ndr->flags = _flags_save_string;
3211                 }
3212                 {
3213                         uint32_t _flags_save_string = ndr->flags;
3214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3216                         ndr->flags = _flags_save_string;
3217                 }
3218                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3223                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3224                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3225         }
3226         if (ndr_flags & NDR_BUFFERS) {
3227                 {
3228                         uint32_t _flags_save_string = ndr->flags;
3229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3230                         if (r->printer_name) {
3231                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3232                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3233                         }
3234                         ndr->flags = _flags_save_string;
3235                 }
3236                 {
3237                         uint32_t _flags_save_string = ndr->flags;
3238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3239                         if (r->server_name) {
3240                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3241                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3242                         }
3243                         ndr->flags = _flags_save_string;
3244                 }
3245                 {
3246                         uint32_t _flags_save_string = ndr->flags;
3247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3248                         if (r->user_name) {
3249                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3250                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3251                         }
3252                         ndr->flags = _flags_save_string;
3253                 }
3254                 {
3255                         uint32_t _flags_save_string = ndr->flags;
3256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3257                         if (r->document_name) {
3258                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3259                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3260                         }
3261                         ndr->flags = _flags_save_string;
3262                 }
3263                 {
3264                         uint32_t _flags_save_string = ndr->flags;
3265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3266                         if (r->data_type) {
3267                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3268                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3269                         }
3270                         ndr->flags = _flags_save_string;
3271                 }
3272                 {
3273                         uint32_t _flags_save_string = ndr->flags;
3274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3275                         if (r->text_status) {
3276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3278                         }
3279                         ndr->flags = _flags_save_string;
3280                 }
3281         }
3282         return NDR_ERR_SUCCESS;
3283 }
3284
3285 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3286 {
3287         uint32_t _ptr_printer_name;
3288         TALLOC_CTX *_mem_save_printer_name_0;
3289         uint32_t _ptr_server_name;
3290         TALLOC_CTX *_mem_save_server_name_0;
3291         uint32_t _ptr_user_name;
3292         TALLOC_CTX *_mem_save_user_name_0;
3293         uint32_t _ptr_document_name;
3294         TALLOC_CTX *_mem_save_document_name_0;
3295         uint32_t _ptr_data_type;
3296         TALLOC_CTX *_mem_save_data_type_0;
3297         uint32_t _ptr_text_status;
3298         TALLOC_CTX *_mem_save_text_status_0;
3299         if (ndr_flags & NDR_SCALARS) {
3300                 NDR_CHECK(ndr_pull_align(ndr, 5));
3301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3302                 {
3303                         uint32_t _flags_save_string = ndr->flags;
3304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3306                         if (_ptr_printer_name) {
3307                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3309                         } else {
3310                                 r->printer_name = NULL;
3311                         }
3312                         ndr->flags = _flags_save_string;
3313                 }
3314                 {
3315                         uint32_t _flags_save_string = ndr->flags;
3316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3318                         if (_ptr_server_name) {
3319                                 NDR_PULL_ALLOC(ndr, r->server_name);
3320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3321                         } else {
3322                                 r->server_name = NULL;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3330                         if (_ptr_user_name) {
3331                                 NDR_PULL_ALLOC(ndr, r->user_name);
3332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3333                         } else {
3334                                 r->user_name = NULL;
3335                         }
3336                         ndr->flags = _flags_save_string;
3337                 }
3338                 {
3339                         uint32_t _flags_save_string = ndr->flags;
3340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3342                         if (_ptr_document_name) {
3343                                 NDR_PULL_ALLOC(ndr, r->document_name);
3344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3345                         } else {
3346                                 r->document_name = NULL;
3347                         }
3348                         ndr->flags = _flags_save_string;
3349                 }
3350                 {
3351                         uint32_t _flags_save_string = ndr->flags;
3352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3354                         if (_ptr_data_type) {
3355                                 NDR_PULL_ALLOC(ndr, r->data_type);
3356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3357                         } else {
3358                                 r->data_type = NULL;
3359                         }
3360                         ndr->flags = _flags_save_string;
3361                 }
3362                 {
3363                         uint32_t _flags_save_string = ndr->flags;
3364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3366                         if (_ptr_text_status) {
3367                                 NDR_PULL_ALLOC(ndr, r->text_status);
3368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3369                         } else {
3370                                 r->text_status = NULL;
3371                         }
3372                         ndr->flags = _flags_save_string;
3373                 }
3374                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3376                 if (r->priority > 99) {
3377                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3378                 }
3379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3382                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3383                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3384         }
3385         if (ndr_flags & NDR_BUFFERS) {
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->printer_name) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3393                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3397                                 if (ndr->offset > ndr->relative_highest_offset) {
3398                                         ndr->relative_highest_offset = ndr->offset;
3399                                 }
3400                                 ndr->offset = _relative_save_offset;
3401                         }
3402                         ndr->flags = _flags_save_string;
3403                 }
3404                 {
3405                         uint32_t _flags_save_string = ndr->flags;
3406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3407                         if (r->server_name) {
3408                                 uint32_t _relative_save_offset;
3409                                 _relative_save_offset = ndr->offset;
3410                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3411                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3412                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3413                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3414                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3415                                 if (ndr->offset > ndr->relative_highest_offset) {
3416                                         ndr->relative_highest_offset = ndr->offset;
3417                                 }
3418                                 ndr->offset = _relative_save_offset;
3419                         }
3420                         ndr->flags = _flags_save_string;
3421                 }
3422                 {
3423                         uint32_t _flags_save_string = ndr->flags;
3424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3425                         if (r->user_name) {
3426                                 uint32_t _relative_save_offset;
3427                                 _relative_save_offset = ndr->offset;
3428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3429                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3430                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3433                                 if (ndr->offset > ndr->relative_highest_offset) {
3434                                         ndr->relative_highest_offset = ndr->offset;
3435                                 }
3436                                 ndr->offset = _relative_save_offset;
3437                         }
3438                         ndr->flags = _flags_save_string;
3439                 }
3440                 {
3441                         uint32_t _flags_save_string = ndr->flags;
3442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3443                         if (r->document_name) {
3444                                 uint32_t _relative_save_offset;
3445                                 _relative_save_offset = ndr->offset;
3446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3447                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3448                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3451                                 if (ndr->offset > ndr->relative_highest_offset) {
3452                                         ndr->relative_highest_offset = ndr->offset;
3453                                 }
3454                                 ndr->offset = _relative_save_offset;
3455                         }
3456                         ndr->flags = _flags_save_string;
3457                 }
3458                 {
3459                         uint32_t _flags_save_string = ndr->flags;
3460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3461                         if (r->data_type) {
3462                                 uint32_t _relative_save_offset;
3463                                 _relative_save_offset = ndr->offset;
3464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3465                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3466                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3469                                 if (ndr->offset > ndr->relative_highest_offset) {
3470                                         ndr->relative_highest_offset = ndr->offset;
3471                                 }
3472                                 ndr->offset = _relative_save_offset;
3473                         }
3474                         ndr->flags = _flags_save_string;
3475                 }
3476                 {
3477                         uint32_t _flags_save_string = ndr->flags;
3478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3479                         if (r->text_status) {
3480                                 uint32_t _relative_save_offset;
3481                                 _relative_save_offset = ndr->offset;
3482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3483                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3484                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3487                                 if (ndr->offset > ndr->relative_highest_offset) {
3488                                         ndr->relative_highest_offset = ndr->offset;
3489                                 }
3490                                 ndr->offset = _relative_save_offset;
3491                         }
3492                         ndr->flags = _flags_save_string;
3493                 }
3494         }
3495         return NDR_ERR_SUCCESS;
3496 }
3497
3498 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3499 {
3500         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3501         ndr->depth++;
3502         ndr_print_uint32(ndr, "job_id", r->job_id);
3503         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3504         ndr->depth++;
3505         if (r->printer_name) {
3506                 ndr_print_string(ndr, "printer_name", r->printer_name);
3507         }
3508         ndr->depth--;
3509         ndr_print_ptr(ndr, "server_name", r->server_name);
3510         ndr->depth++;
3511         if (r->server_name) {
3512                 ndr_print_string(ndr, "server_name", r->server_name);
3513         }
3514         ndr->depth--;
3515         ndr_print_ptr(ndr, "user_name", r->user_name);
3516         ndr->depth++;
3517         if (r->user_name) {
3518                 ndr_print_string(ndr, "user_name", r->user_name);
3519         }
3520         ndr->depth--;
3521         ndr_print_ptr(ndr, "document_name", r->document_name);
3522         ndr->depth++;
3523         if (r->document_name) {
3524                 ndr_print_string(ndr, "document_name", r->document_name);
3525         }
3526         ndr->depth--;
3527         ndr_print_ptr(ndr, "data_type", r->data_type);
3528         ndr->depth++;
3529         if (r->data_type) {
3530                 ndr_print_string(ndr, "data_type", r->data_type);
3531         }
3532         ndr->depth--;
3533         ndr_print_ptr(ndr, "text_status", r->text_status);
3534         ndr->depth++;
3535         if (r->text_status) {
3536                 ndr_print_string(ndr, "text_status", r->text_status);
3537         }
3538         ndr->depth--;
3539         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3540         ndr_print_uint32(ndr, "priority", r->priority);
3541         ndr_print_uint32(ndr, "position", r->position);
3542         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3543         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3544         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3545         ndr->depth--;
3546 }
3547
3548 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3549 {
3550         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3551 }
3552
3553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3554 {
3555         if (ndr_flags & NDR_SCALARS) {
3556                 NDR_CHECK(ndr_push_align(ndr, 5));
3557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3558                 {
3559                         uint32_t _flags_save_string = ndr->flags;
3560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3562                         ndr->flags = _flags_save_string;
3563                 }
3564                 {
3565                         uint32_t _flags_save_string = ndr->flags;
3566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3568                         ndr->flags = _flags_save_string;
3569                 }
3570                 {
3571                         uint32_t _flags_save_string = ndr->flags;
3572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3574                         ndr->flags = _flags_save_string;
3575                 }
3576                 {
3577                         uint32_t _flags_save_string = ndr->flags;
3578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3580                         ndr->flags = _flags_save_string;
3581                 }
3582                 {
3583                         uint32_t _flags_save_string = ndr->flags;
3584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3586                         ndr->flags = _flags_save_string;
3587                 }
3588                 {
3589                         uint32_t _flags_save_string = ndr->flags;
3590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3592                         ndr->flags = _flags_save_string;
3593                 }
3594                 {
3595                         uint32_t _flags_save_string = ndr->flags;
3596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3598                         ndr->flags = _flags_save_string;
3599                 }
3600                 {
3601                         uint32_t _flags_save_string = ndr->flags;
3602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3603                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3604                         ndr->flags = _flags_save_string;
3605                 }
3606                 {
3607                         uint32_t _flags_save_string = ndr->flags;
3608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3610                         ndr->flags = _flags_save_string;
3611                 }
3612                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3613                 {
3614                         uint32_t _flags_save_string = ndr->flags;
3615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3617                         ndr->flags = _flags_save_string;
3618                 }
3619                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3620                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3627                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3630                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3631         }
3632         if (ndr_flags & NDR_BUFFERS) {
3633                 {
3634                         uint32_t _flags_save_string = ndr->flags;
3635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3636                         if (r->printer_name) {
3637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3639                         }
3640                         ndr->flags = _flags_save_string;
3641                 }
3642                 {
3643                         uint32_t _flags_save_string = ndr->flags;
3644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3645                         if (r->server_name) {
3646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3648                         }
3649                         ndr->flags = _flags_save_string;
3650                 }
3651                 {
3652                         uint32_t _flags_save_string = ndr->flags;
3653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3654                         if (r->user_name) {
3655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3657                         }
3658                         ndr->flags = _flags_save_string;
3659                 }
3660                 {
3661                         uint32_t _flags_save_string = ndr->flags;
3662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3663                         if (r->document_name) {
3664                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3666                         }
3667                         ndr->flags = _flags_save_string;
3668                 }
3669                 {
3670                         uint32_t _flags_save_string = ndr->flags;
3671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3672                         if (r->notify_name) {
3673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3675                         }
3676                         ndr->flags = _flags_save_string;
3677                 }
3678                 {
3679                         uint32_t _flags_save_string = ndr->flags;
3680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3681                         if (r->data_type) {
3682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3684                         }
3685                         ndr->flags = _flags_save_string;
3686                 }
3687                 {
3688                         uint32_t _flags_save_string = ndr->flags;
3689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3690                         if (r->print_processor) {
3691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3693                         }
3694                         ndr->flags = _flags_save_string;
3695                 }
3696                 {
3697                         uint32_t _flags_save_string = ndr->flags;
3698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3699                         if (r->parameters) {
3700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3702                         }
3703                         ndr->flags = _flags_save_string;
3704                 }
3705                 {
3706                         uint32_t _flags_save_string = ndr->flags;
3707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3708                         if (r->driver_name) {
3709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3711                         }
3712                         ndr->flags = _flags_save_string;
3713                 }
3714                 if (r->devmode) {
3715                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3716                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3717                 }
3718                 {
3719                         uint32_t _flags_save_string = ndr->flags;
3720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3721                         if (r->text_status) {
3722                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3723                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3724                         }
3725                         ndr->flags = _flags_save_string;
3726                 }
3727                 if (r->secdesc) {
3728                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3729                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3730                 }
3731         }
3732         return NDR_ERR_SUCCESS;
3733 }
3734
3735 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3736 {
3737         uint32_t _ptr_printer_name;
3738         TALLOC_CTX *_mem_save_printer_name_0;
3739         uint32_t _ptr_server_name;
3740         TALLOC_CTX *_mem_save_server_name_0;
3741         uint32_t _ptr_user_name;
3742         TALLOC_CTX *_mem_save_user_name_0;
3743         uint32_t _ptr_document_name;
3744         TALLOC_CTX *_mem_save_document_name_0;
3745         uint32_t _ptr_notify_name;
3746         TALLOC_CTX *_mem_save_notify_name_0;
3747         uint32_t _ptr_data_type;
3748         TALLOC_CTX *_mem_save_data_type_0;
3749         uint32_t _ptr_print_processor;
3750         TALLOC_CTX *_mem_save_print_processor_0;
3751         uint32_t _ptr_parameters;
3752         TALLOC_CTX *_mem_save_parameters_0;
3753         uint32_t _ptr_driver_name;
3754         TALLOC_CTX *_mem_save_driver_name_0;
3755         uint32_t _ptr_devmode;
3756         TALLOC_CTX *_mem_save_devmode_0;
3757         uint32_t _ptr_text_status;
3758         TALLOC_CTX *_mem_save_text_status_0;
3759         uint32_t _ptr_secdesc;
3760         TALLOC_CTX *_mem_save_secdesc_0;
3761         if (ndr_flags & NDR_SCALARS) {
3762                 NDR_CHECK(ndr_pull_align(ndr, 5));
3763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3768                         if (_ptr_printer_name) {
3769                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3771                         } else {
3772                                 r->printer_name = NULL;
3773                         }
3774                         ndr->flags = _flags_save_string;
3775                 }
3776                 {
3777                         uint32_t _flags_save_string = ndr->flags;
3778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3780                         if (_ptr_server_name) {
3781                                 NDR_PULL_ALLOC(ndr, r->server_name);
3782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3783                         } else {
3784                                 r->server_name = NULL;
3785                         }
3786                         ndr->flags = _flags_save_string;
3787                 }
3788                 {
3789                         uint32_t _flags_save_string = ndr->flags;
3790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3792                         if (_ptr_user_name) {
3793                                 NDR_PULL_ALLOC(ndr, r->user_name);
3794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3795                         } else {
3796                                 r->user_name = NULL;
3797                         }
3798                         ndr->flags = _flags_save_string;
3799                 }
3800                 {
3801                         uint32_t _flags_save_string = ndr->flags;
3802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3803                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3804                         if (_ptr_document_name) {
3805                                 NDR_PULL_ALLOC(ndr, r->document_name);
3806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3807                         } else {
3808                                 r->document_name = NULL;
3809                         }
3810                         ndr->flags = _flags_save_string;
3811                 }
3812                 {
3813                         uint32_t _flags_save_string = ndr->flags;
3814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3816                         if (_ptr_notify_name) {
3817                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3819                         } else {
3820                                 r->notify_name = NULL;
3821                         }
3822                         ndr->flags = _flags_save_string;
3823                 }
3824                 {
3825                         uint32_t _flags_save_string = ndr->flags;
3826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3827                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3828                         if (_ptr_data_type) {
3829                                 NDR_PULL_ALLOC(ndr, r->data_type);
3830                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3831                         } else {
3832                                 r->data_type = NULL;
3833                         }
3834                         ndr->flags = _flags_save_string;
3835                 }
3836                 {
3837                         uint32_t _flags_save_string = ndr->flags;
3838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3839                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3840                         if (_ptr_print_processor) {
3841                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3842                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3843                         } else {
3844                                 r->print_processor = NULL;
3845                         }
3846                         ndr->flags = _flags_save_string;
3847                 }
3848                 {
3849                         uint32_t _flags_save_string = ndr->flags;
3850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3851                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3852                         if (_ptr_parameters) {
3853                                 NDR_PULL_ALLOC(ndr, r->parameters);
3854                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3855                         } else {
3856                                 r->parameters = NULL;
3857                         }
3858                         ndr->flags = _flags_save_string;
3859                 }
3860                 {
3861                         uint32_t _flags_save_string = ndr->flags;
3862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3863                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3864                         if (_ptr_driver_name) {
3865                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3866                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3867                         } else {
3868                                 r->driver_name = NULL;
3869                         }
3870                         ndr->flags = _flags_save_string;
3871                 }
3872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3873                 if (_ptr_devmode) {
3874                         NDR_PULL_ALLOC(ndr, r->devmode);
3875                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3876                 } else {
3877                         r->devmode = NULL;
3878                 }
3879                 {
3880                         uint32_t _flags_save_string = ndr->flags;
3881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3883                         if (_ptr_text_status) {
3884                                 NDR_PULL_ALLOC(ndr, r->text_status);
3885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3886                         } else {
3887                                 r->text_status = NULL;
3888                         }
3889                         ndr->flags = _flags_save_string;
3890                 }
3891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3892                 if (_ptr_secdesc) {
3893                         NDR_PULL_ALLOC(ndr, r->secdesc);
3894                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3895                 } else {
3896                         r->secdesc = NULL;
3897                 }
3898                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3900                 if (r->priority > 99) {
3901                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3902                 }
3903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3908                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3911                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3912         }
3913         if (ndr_flags & NDR_BUFFERS) {
3914                 {
3915                         uint32_t _flags_save_string = ndr->flags;
3916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3917                         if (r->printer_name) {
3918                                 uint32_t _relative_save_offset;
3919                                 _relative_save_offset = ndr->offset;
3920                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3921                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3922                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3923                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3924                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3925                                 if (ndr->offset > ndr->relative_highest_offset) {
3926                                         ndr->relative_highest_offset = ndr->offset;
3927                                 }
3928                                 ndr->offset = _relative_save_offset;
3929                         }
3930                         ndr->flags = _flags_save_string;
3931                 }
3932                 {
3933                         uint32_t _flags_save_string = ndr->flags;
3934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3935                         if (r->server_name) {
3936                                 uint32_t _relative_save_offset;
3937                                 _relative_save_offset = ndr->offset;
3938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3939                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3940                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3943                                 if (ndr->offset > ndr->relative_highest_offset) {
3944                                         ndr->relative_highest_offset = ndr->offset;
3945                                 }
3946                                 ndr->offset = _relative_save_offset;
3947                         }
3948                         ndr->flags = _flags_save_string;
3949                 }
3950                 {
3951                         uint32_t _flags_save_string = ndr->flags;
3952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3953                         if (r->user_name) {
3954                                 uint32_t _relative_save_offset;
3955                                 _relative_save_offset = ndr->offset;
3956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3957                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3958                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3961                                 if (ndr->offset > ndr->relative_highest_offset) {
3962                                         ndr->relative_highest_offset = ndr->offset;
3963                                 }
3964                                 ndr->offset = _relative_save_offset;
3965                         }
3966                         ndr->flags = _flags_save_string;
3967                 }
3968                 {
3969                         uint32_t _flags_save_string = ndr->flags;
3970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3971                         if (r->document_name) {
3972                                 uint32_t _relative_save_offset;
3973                                 _relative_save_offset = ndr->offset;
3974                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3975                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3976                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3977                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3978                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3979                                 if (ndr->offset > ndr->relative_highest_offset) {
3980                                         ndr->relative_highest_offset = ndr->offset;
3981                                 }
3982                                 ndr->offset = _relative_save_offset;
3983                         }
3984                         ndr->flags = _flags_save_string;
3985                 }
3986                 {
3987                         uint32_t _flags_save_string = ndr->flags;
3988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3989                         if (r->notify_name) {
3990                                 uint32_t _relative_save_offset;
3991                                 _relative_save_offset = ndr->offset;
3992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3993                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3994                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3995                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3997                                 if (ndr->offset > ndr->relative_highest_offset) {
3998                                         ndr->relative_highest_offset = ndr->offset;
3999                                 }
4000                                 ndr->offset = _relative_save_offset;
4001                         }
4002                         ndr->flags = _flags_save_string;
4003                 }
4004                 {
4005                         uint32_t _flags_save_string = ndr->flags;
4006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4007                         if (r->data_type) {
4008                                 uint32_t _relative_save_offset;
4009                                 _relative_save_offset = ndr->offset;
4010                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4011                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4012                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4013                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4014                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4015                                 if (ndr->offset > ndr->relative_highest_offset) {
4016                                         ndr->relative_highest_offset = ndr->offset;
4017                                 }
4018                                 ndr->offset = _relative_save_offset;
4019                         }
4020                         ndr->flags = _flags_save_string;
4021                 }
4022                 {
4023                         uint32_t _flags_save_string = ndr->flags;
4024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4025                         if (r->print_processor) {
4026                                 uint32_t _relative_save_offset;
4027                                 _relative_save_offset = ndr->offset;
4028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4029                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4030                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4031                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4033                                 if (ndr->offset > ndr->relative_highest_offset) {
4034                                         ndr->relative_highest_offset = ndr->offset;
4035                                 }
4036                                 ndr->offset = _relative_save_offset;
4037                         }
4038                         ndr->flags = _flags_save_string;
4039                 }
4040                 {
4041                         uint32_t _flags_save_string = ndr->flags;
4042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4043                         if (r->parameters) {
4044                                 uint32_t _relative_save_offset;
4045                                 _relative_save_offset = ndr->offset;
4046                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4047                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4048                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4049                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4050                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4051                                 if (ndr->offset > ndr->relative_highest_offset) {
4052                                         ndr->relative_highest_offset = ndr->offset;
4053                                 }
4054                                 ndr->offset = _relative_save_offset;
4055                         }
4056                         ndr->flags = _flags_save_string;
4057                 }
4058                 {
4059                         uint32_t _flags_save_string = ndr->flags;
4060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4061                         if (r->driver_name) {
4062                                 uint32_t _relative_save_offset;
4063                                 _relative_save_offset = ndr->offset;
4064                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4065                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4066                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4067                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4069                                 if (ndr->offset > ndr->relative_highest_offset) {
4070                                         ndr->relative_highest_offset = ndr->offset;
4071                                 }
4072                                 ndr->offset = _relative_save_offset;
4073                         }
4074                         ndr->flags = _flags_save_string;
4075                 }
4076                 if (r->devmode) {
4077                         uint32_t _relative_save_offset;
4078                         _relative_save_offset = ndr->offset;
4079                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4080                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4081                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4082                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4084                         if (ndr->offset > ndr->relative_highest_offset) {
4085                                 ndr->relative_highest_offset = ndr->offset;
4086                         }
4087                         ndr->offset = _relative_save_offset;
4088                 }
4089                 {
4090                         uint32_t _flags_save_string = ndr->flags;
4091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4092                         if (r->text_status) {
4093                                 uint32_t _relative_save_offset;
4094                                 _relative_save_offset = ndr->offset;
4095                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4096                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4097                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4098                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4099                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4100                                 if (ndr->offset > ndr->relative_highest_offset) {
4101                                         ndr->relative_highest_offset = ndr->offset;
4102                                 }
4103                                 ndr->offset = _relative_save_offset;
4104                         }
4105                         ndr->flags = _flags_save_string;
4106                 }
4107                 if (r->secdesc) {
4108                         uint32_t _relative_save_offset;
4109                         _relative_save_offset = ndr->offset;
4110                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4111                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4112                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4113                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4115                         if (ndr->offset > ndr->relative_highest_offset) {
4116                                 ndr->relative_highest_offset = ndr->offset;
4117                         }
4118                         ndr->offset = _relative_save_offset;
4119                 }
4120         }
4121         return NDR_ERR_SUCCESS;
4122 }
4123
4124 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4125 {
4126         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4127         ndr->depth++;
4128         ndr_print_uint32(ndr, "job_id", r->job_id);
4129         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4130         ndr->depth++;
4131         if (r->printer_name) {
4132                 ndr_print_string(ndr, "printer_name", r->printer_name);
4133         }
4134         ndr->depth--;
4135         ndr_print_ptr(ndr, "server_name", r->server_name);
4136         ndr->depth++;
4137         if (r->server_name) {
4138                 ndr_print_string(ndr, "server_name", r->server_name);
4139         }
4140         ndr->depth--;
4141         ndr_print_ptr(ndr, "user_name", r->user_name);
4142         ndr->depth++;
4143         if (r->user_name) {
4144                 ndr_print_string(ndr, "user_name", r->user_name);
4145         }
4146         ndr->depth--;
4147         ndr_print_ptr(ndr, "document_name", r->document_name);
4148         ndr->depth++;
4149         if (r->document_name) {
4150                 ndr_print_string(ndr, "document_name", r->document_name);
4151         }
4152         ndr->depth--;
4153         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4154         ndr->depth++;
4155         if (r->notify_name) {
4156                 ndr_print_string(ndr, "notify_name", r->notify_name);
4157         }
4158         ndr->depth--;
4159         ndr_print_ptr(ndr, "data_type", r->data_type);
4160         ndr->depth++;
4161         if (r->data_type) {
4162                 ndr_print_string(ndr, "data_type", r->data_type);
4163         }
4164         ndr->depth--;
4165         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4166         ndr->depth++;
4167         if (r->print_processor) {
4168                 ndr_print_string(ndr, "print_processor", r->print_processor);
4169         }
4170         ndr->depth--;
4171         ndr_print_ptr(ndr, "parameters", r->parameters);
4172         ndr->depth++;
4173         if (r->parameters) {
4174                 ndr_print_string(ndr, "parameters", r->parameters);
4175         }
4176         ndr->depth--;
4177         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4178         ndr->depth++;
4179         if (r->driver_name) {
4180                 ndr_print_string(ndr, "driver_name", r->driver_name);
4181         }
4182         ndr->depth--;
4183         ndr_print_ptr(ndr, "devmode", r->devmode);
4184         ndr->depth++;
4185         if (r->devmode) {
4186                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4187         }
4188         ndr->depth--;
4189         ndr_print_ptr(ndr, "text_status", r->text_status);
4190         ndr->depth++;
4191         if (r->text_status) {
4192                 ndr_print_string(ndr, "text_status", r->text_status);
4193         }
4194         ndr->depth--;
4195         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4196         ndr->depth++;
4197         if (r->secdesc) {
4198                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4199         }
4200         ndr->depth--;
4201         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4202         ndr_print_uint32(ndr, "priority", r->priority);
4203         ndr_print_uint32(ndr, "position", r->position);
4204         ndr_print_uint32(ndr, "start_time", r->start_time);
4205         ndr_print_uint32(ndr, "until_time", r->until_time);
4206         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4207         ndr_print_uint32(ndr, "size", r->size);
4208         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4209         ndr_print_uint32(ndr, "time", r->time);
4210         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4211         ndr->depth--;
4212 }
4213
4214 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4215 {
4216         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4217 }
4218
4219 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4220 {
4221         if (ndr_flags & NDR_SCALARS) {
4222                 NDR_CHECK(ndr_push_align(ndr, 4));
4223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4226                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4227         }
4228         if (ndr_flags & NDR_BUFFERS) {
4229         }
4230         return NDR_ERR_SUCCESS;
4231 }
4232
4233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4234 {
4235         if (ndr_flags & NDR_SCALARS) {
4236                 NDR_CHECK(ndr_pull_align(ndr, 4));
4237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4240                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4241         }
4242         if (ndr_flags & NDR_BUFFERS) {
4243         }
4244         return NDR_ERR_SUCCESS;
4245 }
4246
4247 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4248 {
4249         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4250         ndr->depth++;
4251         ndr_print_uint32(ndr, "job_id", r->job_id);
4252         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4253         ndr_print_uint32(ndr, "reserved", r->reserved);
4254         ndr->depth--;
4255 }
4256
4257 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4258 {
4259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4260 }
4261
4262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4263 {
4264         if (ndr_flags & NDR_SCALARS) {
4265                 NDR_CHECK(ndr_push_align(ndr, 5));
4266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4267                 {
4268                         uint32_t _flags_save_string = ndr->flags;
4269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4270                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4271                         ndr->flags = _flags_save_string;
4272                 }
4273                 {
4274                         uint32_t _flags_save_string = ndr->flags;
4275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4276                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4277                         ndr->flags = _flags_save_string;
4278                 }
4279                 {
4280                         uint32_t _flags_save_string = ndr->flags;
4281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4282                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4283                         ndr->flags = _flags_save_string;
4284                 }
4285                 {
4286                         uint32_t _flags_save_string = ndr->flags;
4287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4289                         ndr->flags = _flags_save_string;
4290                 }
4291                 {
4292                         uint32_t _flags_save_string = ndr->flags;
4293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4295                         ndr->flags = _flags_save_string;
4296                 }
4297                 {
4298                         uint32_t _flags_save_string = ndr->flags;
4299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4301                         ndr->flags = _flags_save_string;
4302                 }
4303                 {
4304                         uint32_t _flags_save_string = ndr->flags;
4305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4307                         ndr->flags = _flags_save_string;
4308                 }
4309                 {
4310                         uint32_t _flags_save_string = ndr->flags;
4311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4313                         ndr->flags = _flags_save_string;
4314                 }
4315                 {
4316                         uint32_t _flags_save_string = ndr->flags;
4317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4319                         ndr->flags = _flags_save_string;
4320                 }
4321                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4322                 {
4323                         uint32_t _flags_save_string = ndr->flags;
4324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4325                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4326                         ndr->flags = _flags_save_string;
4327                 }
4328                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4329                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4336                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4341         }
4342         if (ndr_flags & NDR_BUFFERS) {
4343                 {
4344                         uint32_t _flags_save_string = ndr->flags;
4345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4346                         if (r->printer_name) {
4347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
4348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4349                         }
4350                         ndr->flags = _flags_save_string;
4351                 }
4352                 {
4353                         uint32_t _flags_save_string = ndr->flags;
4354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4355                         if (r->server_name) {
4356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
4357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4358                         }
4359                         ndr->flags = _flags_save_string;
4360                 }
4361                 {
4362                         uint32_t _flags_save_string = ndr->flags;
4363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4364                         if (r->user_name) {
4365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
4366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4367                         }
4368                         ndr->flags = _flags_save_string;
4369                 }
4370                 {
4371                         uint32_t _flags_save_string = ndr->flags;
4372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4373                         if (r->document_name) {
4374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
4375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4376                         }
4377                         ndr->flags = _flags_save_string;
4378                 }
4379                 {
4380                         uint32_t _flags_save_string = ndr->flags;
4381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4382                         if (r->notify_name) {
4383                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
4384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4385                         }
4386                         ndr->flags = _flags_save_string;
4387                 }
4388                 {
4389                         uint32_t _flags_save_string = ndr->flags;
4390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4391                         if (r->data_type) {
4392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
4393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4394                         }
4395                         ndr->flags = _flags_save_string;
4396                 }
4397                 {
4398                         uint32_t _flags_save_string = ndr->flags;
4399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4400                         if (r->print_processor) {
4401                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
4402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4403                         }
4404                         ndr->flags = _flags_save_string;
4405                 }
4406                 {
4407                         uint32_t _flags_save_string = ndr->flags;
4408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4409                         if (r->parameters) {
4410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
4411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4412                         }
4413                         ndr->flags = _flags_save_string;
4414                 }
4415                 {
4416                         uint32_t _flags_save_string = ndr->flags;
4417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4418                         if (r->driver_name) {
4419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4421                         }
4422                         ndr->flags = _flags_save_string;
4423                 }
4424                 if (r->devmode) {
4425                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
4426                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4427                 }
4428                 {
4429                         uint32_t _flags_save_string = ndr->flags;
4430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4431                         if (r->text_status) {
4432                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
4433                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4434                         }
4435                         ndr->flags = _flags_save_string;
4436                 }
4437                 if (r->secdesc) {
4438                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
4439                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4440                 }
4441         }
4442         return NDR_ERR_SUCCESS;
4443 }
4444
4445 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4446 {
4447         uint32_t _ptr_printer_name;
4448         TALLOC_CTX *_mem_save_printer_name_0;
4449         uint32_t _ptr_server_name;
4450         TALLOC_CTX *_mem_save_server_name_0;
4451         uint32_t _ptr_user_name;
4452         TALLOC_CTX *_mem_save_user_name_0;
4453         uint32_t _ptr_document_name;
4454         TALLOC_CTX *_mem_save_document_name_0;
4455         uint32_t _ptr_notify_name;
4456         TALLOC_CTX *_mem_save_notify_name_0;
4457         uint32_t _ptr_data_type;
4458         TALLOC_CTX *_mem_save_data_type_0;
4459         uint32_t _ptr_print_processor;
4460         TALLOC_CTX *_mem_save_print_processor_0;
4461         uint32_t _ptr_parameters;
4462         TALLOC_CTX *_mem_save_parameters_0;
4463         uint32_t _ptr_driver_name;
4464         TALLOC_CTX *_mem_save_driver_name_0;
4465         uint32_t _ptr_devmode;
4466         TALLOC_CTX *_mem_save_devmode_0;
4467         uint32_t _ptr_text_status;
4468         TALLOC_CTX *_mem_save_text_status_0;
4469         uint32_t _ptr_secdesc;
4470         TALLOC_CTX *_mem_save_secdesc_0;
4471         if (ndr_flags & NDR_SCALARS) {
4472                 NDR_CHECK(ndr_pull_align(ndr, 5));
4473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4474                 {
4475                         uint32_t _flags_save_string = ndr->flags;
4476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4477                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4478                         if (_ptr_printer_name) {
4479                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4480                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4481                         } else {
4482                                 r->printer_name = NULL;
4483                         }
4484                         ndr->flags = _flags_save_string;
4485                 }
4486                 {
4487                         uint32_t _flags_save_string = ndr->flags;
4488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4489                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4490                         if (_ptr_server_name) {
4491                                 NDR_PULL_ALLOC(ndr, r->server_name);
4492                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4493                         } else {
4494                                 r->server_name = NULL;
4495                         }
4496                         ndr->flags = _flags_save_string;
4497                 }
4498                 {
4499                         uint32_t _flags_save_string = ndr->flags;
4500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4501                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4502                         if (_ptr_user_name) {
4503                                 NDR_PULL_ALLOC(ndr, r->user_name);
4504                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4505                         } else {
4506                                 r->user_name = NULL;
4507                         }
4508                         ndr->flags = _flags_save_string;
4509                 }
4510                 {
4511                         uint32_t _flags_save_string = ndr->flags;
4512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4514                         if (_ptr_document_name) {
4515                                 NDR_PULL_ALLOC(ndr, r->document_name);
4516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4517                         } else {
4518                                 r->document_name = NULL;
4519                         }
4520                         ndr->flags = _flags_save_string;
4521                 }
4522                 {
4523                         uint32_t _flags_save_string = ndr->flags;
4524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4525                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4526                         if (_ptr_notify_name) {
4527                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4528                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4529                         } else {
4530                                 r->notify_name = NULL;
4531                         }
4532                         ndr->flags = _flags_save_string;
4533                 }
4534                 {
4535                         uint32_t _flags_save_string = ndr->flags;
4536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4538                         if (_ptr_data_type) {
4539                                 NDR_PULL_ALLOC(ndr, r->data_type);
4540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4541                         } else {
4542                                 r->data_type = NULL;
4543                         }
4544                         ndr->flags = _flags_save_string;
4545                 }
4546                 {
4547                         uint32_t _flags_save_string = ndr->flags;
4548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4550                         if (_ptr_print_processor) {
4551                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4553                         } else {
4554                                 r->print_processor = NULL;
4555                         }
4556                         ndr->flags = _flags_save_string;
4557                 }
4558                 {
4559                         uint32_t _flags_save_string = ndr->flags;
4560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4562                         if (_ptr_parameters) {
4563                                 NDR_PULL_ALLOC(ndr, r->parameters);
4564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4565                         } else {
4566                                 r->parameters = NULL;
4567                         }
4568                         ndr->flags = _flags_save_string;
4569                 }
4570                 {
4571                         uint32_t _flags_save_string = ndr->flags;
4572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4573                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4574                         if (_ptr_driver_name) {
4575                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4576                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4577                         } else {
4578                                 r->driver_name = NULL;
4579                         }
4580                         ndr->flags = _flags_save_string;
4581                 }
4582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4583                 if (_ptr_devmode) {
4584                         NDR_PULL_ALLOC(ndr, r->devmode);
4585                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4586                 } else {
4587                         r->devmode = NULL;
4588                 }
4589                 {
4590                         uint32_t _flags_save_string = ndr->flags;
4591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4592                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4593                         if (_ptr_text_status) {
4594                                 NDR_PULL_ALLOC(ndr, r->text_status);
4595                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4596                         } else {
4597                                 r->text_status = NULL;
4598                         }
4599                         ndr->flags = _flags_save_string;
4600                 }
4601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4602                 if (_ptr_secdesc) {
4603                         NDR_PULL_ALLOC(ndr, r->secdesc);
4604                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4605                 } else {
4606                         r->secdesc = NULL;
4607                 }
4608                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4610                 if (r->priority > 99) {
4611                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4612                 }
4613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4618                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4623         }
4624         if (ndr_flags & NDR_BUFFERS) {
4625                 {
4626                         uint32_t _flags_save_string = ndr->flags;
4627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4628                         if (r->printer_name) {
4629                                 uint32_t _relative_save_offset;
4630                                 _relative_save_offset = ndr->offset;
4631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4632                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4633                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4636                                 if (ndr->offset > ndr->relative_highest_offset) {
4637                                         ndr->relative_highest_offset = ndr->offset;
4638                                 }
4639                                 ndr->offset = _relative_save_offset;
4640                         }
4641                         ndr->flags = _flags_save_string;
4642                 }
4643                 {
4644                         uint32_t _flags_save_string = ndr->flags;
4645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4646                         if (r->server_name) {
4647                                 uint32_t _relative_save_offset;
4648                                 _relative_save_offset = ndr->offset;
4649                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4650                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4651                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4652                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4653                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4654                                 if (ndr->offset > ndr->relative_highest_offset) {
4655                                         ndr->relative_highest_offset = ndr->offset;
4656                                 }
4657                                 ndr->offset = _relative_save_offset;
4658                         }
4659                         ndr->flags = _flags_save_string;
4660                 }
4661                 {
4662                         uint32_t _flags_save_string = ndr->flags;
4663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4664                         if (r->user_name) {
4665                                 uint32_t _relative_save_offset;
4666                                 _relative_save_offset = ndr->offset;
4667                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4668                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4669                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4670                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4671                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4672                                 if (ndr->offset > ndr->relative_highest_offset) {
4673                                         ndr->relative_highest_offset = ndr->offset;
4674                                 }
4675                                 ndr->offset = _relative_save_offset;
4676                         }
4677                         ndr->flags = _flags_save_string;
4678                 }
4679                 {
4680                         uint32_t _flags_save_string = ndr->flags;
4681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4682                         if (r->document_name) {
4683                                 uint32_t _relative_save_offset;
4684                                 _relative_save_offset = ndr->offset;
4685                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4686                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4687                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4688                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4689                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4690                                 if (ndr->offset > ndr->relative_highest_offset) {
4691                                         ndr->relative_highest_offset = ndr->offset;
4692                                 }
4693                                 ndr->offset = _relative_save_offset;
4694                         }
4695                         ndr->flags = _flags_save_string;
4696                 }
4697                 {
4698                         uint32_t _flags_save_string = ndr->flags;
4699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4700                         if (r->notify_name) {
4701                                 uint32_t _relative_save_offset;
4702                                 _relative_save_offset = ndr->offset;
4703                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4704                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4705                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4706                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4707                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4708                                 if (ndr->offset > ndr->relative_highest_offset) {
4709                                         ndr->relative_highest_offset = ndr->offset;
4710                                 }
4711                                 ndr->offset = _relative_save_offset;
4712                         }
4713                         ndr->flags = _flags_save_string;
4714                 }
4715                 {
4716                         uint32_t _flags_save_string = ndr->flags;
4717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4718                         if (r->data_type) {
4719                                 uint32_t _relative_save_offset;
4720                                 _relative_save_offset = ndr->offset;
4721                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4722                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4723                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4724                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4725                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4726                                 if (ndr->offset > ndr->relative_highest_offset) {
4727                                         ndr->relative_highest_offset = ndr->offset;
4728                                 }
4729                                 ndr->offset = _relative_save_offset;
4730                         }
4731                         ndr->flags = _flags_save_string;
4732                 }
4733                 {
4734                         uint32_t _flags_save_string = ndr->flags;
4735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4736                         if (r->print_processor) {
4737                                 uint32_t _relative_save_offset;
4738                                 _relative_save_offset = ndr->offset;
4739                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4740                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4741                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4742                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4743                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4744                                 if (ndr->offset > ndr->relative_highest_offset) {
4745                                         ndr->relative_highest_offset = ndr->offset;
4746                                 }
4747                                 ndr->offset = _relative_save_offset;
4748                         }
4749                         ndr->flags = _flags_save_string;
4750                 }
4751                 {
4752                         uint32_t _flags_save_string = ndr->flags;
4753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4754                         if (r->parameters) {
4755                                 uint32_t _relative_save_offset;
4756                                 _relative_save_offset = ndr->offset;
4757                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4758                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4759                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4760                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4761                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4762                                 if (ndr->offset > ndr->relative_highest_offset) {
4763                                         ndr->relative_highest_offset = ndr->offset;
4764                                 }
4765                                 ndr->offset = _relative_save_offset;
4766                         }
4767                         ndr->flags = _flags_save_string;
4768                 }
4769                 {
4770                         uint32_t _flags_save_string = ndr->flags;
4771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4772                         if (r->driver_name) {
4773                                 uint32_t _relative_save_offset;
4774                                 _relative_save_offset = ndr->offset;
4775                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4776                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4777                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4778                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4779                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4780                                 if (ndr->offset > ndr->relative_highest_offset) {
4781                                         ndr->relative_highest_offset = ndr->offset;
4782                                 }
4783                                 ndr->offset = _relative_save_offset;
4784                         }
4785                         ndr->flags = _flags_save_string;
4786                 }
4787                 if (r->devmode) {
4788                         uint32_t _relative_save_offset;
4789                         _relative_save_offset = ndr->offset;
4790                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4791                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4792                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4793                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4795                         if (ndr->offset > ndr->relative_highest_offset) {
4796                                 ndr->relative_highest_offset = ndr->offset;
4797                         }
4798                         ndr->offset = _relative_save_offset;
4799                 }
4800                 {
4801                         uint32_t _flags_save_string = ndr->flags;
4802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4803                         if (r->text_status) {
4804                                 uint32_t _relative_save_offset;
4805                                 _relative_save_offset = ndr->offset;
4806                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4807                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4808                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4809                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4810                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4811                                 if (ndr->offset > ndr->relative_highest_offset) {
4812                                         ndr->relative_highest_offset = ndr->offset;
4813                                 }
4814                                 ndr->offset = _relative_save_offset;
4815                         }
4816                         ndr->flags = _flags_save_string;
4817                 }
4818                 if (r->secdesc) {
4819                         uint32_t _relative_save_offset;
4820                         _relative_save_offset = ndr->offset;
4821                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4822                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4823                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4824                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4826                         if (ndr->offset > ndr->relative_highest_offset) {
4827                                 ndr->relative_highest_offset = ndr->offset;
4828                         }
4829                         ndr->offset = _relative_save_offset;
4830                 }
4831         }
4832         return NDR_ERR_SUCCESS;
4833 }
4834
4835 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4836 {
4837         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4838         ndr->depth++;
4839         ndr_print_uint32(ndr, "job_id", r->job_id);
4840         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4841         ndr->depth++;
4842         if (r->printer_name) {
4843                 ndr_print_string(ndr, "printer_name", r->printer_name);
4844         }
4845         ndr->depth--;
4846         ndr_print_ptr(ndr, "server_name", r->server_name);
4847         ndr->depth++;
4848         if (r->server_name) {
4849                 ndr_print_string(ndr, "server_name", r->server_name);
4850         }
4851         ndr->depth--;
4852         ndr_print_ptr(ndr, "user_name", r->user_name);
4853         ndr->depth++;
4854         if (r->user_name) {
4855                 ndr_print_string(ndr, "user_name", r->user_name);
4856         }
4857         ndr->depth--;
4858         ndr_print_ptr(ndr, "document_name", r->document_name);
4859         ndr->depth++;
4860         if (r->document_name) {
4861                 ndr_print_string(ndr, "document_name", r->document_name);
4862         }
4863         ndr->depth--;
4864         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4865         ndr->depth++;
4866         if (r->notify_name) {
4867                 ndr_print_string(ndr, "notify_name", r->notify_name);
4868         }
4869         ndr->depth--;
4870         ndr_print_ptr(ndr, "data_type", r->data_type);
4871         ndr->depth++;
4872         if (r->data_type) {
4873                 ndr_print_string(ndr, "data_type", r->data_type);
4874         }
4875         ndr->depth--;
4876         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4877         ndr->depth++;
4878         if (r->print_processor) {
4879                 ndr_print_string(ndr, "print_processor", r->print_processor);
4880         }
4881         ndr->depth--;
4882         ndr_print_ptr(ndr, "parameters", r->parameters);
4883         ndr->depth++;
4884         if (r->parameters) {
4885                 ndr_print_string(ndr, "parameters", r->parameters);
4886         }
4887         ndr->depth--;
4888         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4889         ndr->depth++;
4890         if (r->driver_name) {
4891                 ndr_print_string(ndr, "driver_name", r->driver_name);
4892         }
4893         ndr->depth--;
4894         ndr_print_ptr(ndr, "devmode", r->devmode);
4895         ndr->depth++;
4896         if (r->devmode) {
4897                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4898         }
4899         ndr->depth--;
4900         ndr_print_ptr(ndr, "text_status", r->text_status);
4901         ndr->depth++;
4902         if (r->text_status) {
4903                 ndr_print_string(ndr, "text_status", r->text_status);
4904         }
4905         ndr->depth--;
4906         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4907         ndr->depth++;
4908         if (r->secdesc) {
4909                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4910         }
4911         ndr->depth--;
4912         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4913         ndr_print_uint32(ndr, "priority", r->priority);
4914         ndr_print_uint32(ndr, "position", r->position);
4915         ndr_print_uint32(ndr, "start_time", r->start_time);
4916         ndr_print_uint32(ndr, "until_time", r->until_time);
4917         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4918         ndr_print_uint32(ndr, "size", r->size);
4919         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4920         ndr_print_uint32(ndr, "time", r->time);
4921         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4922         ndr_print_uint32(ndr, "size_high", r->size_high);
4923         ndr->depth--;
4924 }
4925
4926 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4927 {
4928         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4929 }
4930
4931 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4932 {
4933         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4934         if (ndr_flags & NDR_SCALARS) {
4935                 int level = ndr_push_get_switch_value(ndr, r);
4936                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4937                 switch (level) {
4938                         case 1: {
4939                                 NDR_CHECK(ndr_push_align(ndr, 5));
4940                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4941                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4942                         break; }
4943
4944                         case 2: {
4945                                 NDR_CHECK(ndr_push_align(ndr, 5));
4946                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4947                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4948                         break; }
4949
4950                         case 3: {
4951                                 NDR_CHECK(ndr_push_align(ndr, 4));
4952                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4953                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4954                         break; }
4955
4956                         case 4: {
4957                                 NDR_CHECK(ndr_push_align(ndr, 5));
4958                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4959                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4960                         break; }
4961
4962                         default: {
4963                         break; }
4964
4965                 }
4966         }
4967         if (ndr_flags & NDR_BUFFERS) {
4968                 int level = ndr_push_get_switch_value(ndr, r);
4969                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4970                 switch (level) {
4971                         case 1:
4972                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4973                         break;
4974
4975                         case 2:
4976                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4977                         break;
4978
4979                         case 3:
4980                         break;
4981
4982                         case 4:
4983                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4984                         break;
4985
4986                         default:
4987                         break;
4988
4989                 }
4990         }
4991         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4992         return NDR_ERR_SUCCESS;
4993 }
4994
4995 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4996 {
4997         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4998         int level;
4999         level = ndr_pull_get_switch_value(ndr, r);
5000         if (ndr_flags & NDR_SCALARS) {
5001                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5002                 switch (level) {
5003                         case 1: {
5004                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5005                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5006                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5007                         break; }
5008
5009                         case 2: {
5010                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5011                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5012                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5013                         break; }
5014
5015                         case 3: {
5016                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5017                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5018                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5019                         break; }
5020
5021                         case 4: {
5022                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5023                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5024                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5025                         break; }
5026
5027                         default: {
5028                         break; }
5029
5030                 }
5031         }
5032         if (ndr_flags & NDR_BUFFERS) {
5033                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5034                 switch (level) {
5035                         case 1:
5036                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5037                         break;
5038
5039                         case 2:
5040                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5041                         break;
5042
5043                         case 3:
5044                         break;
5045
5046                         case 4:
5047                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5048                         break;
5049
5050                         default:
5051                         break;
5052
5053                 }
5054         }
5055         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5056         return NDR_ERR_SUCCESS;
5057 }
5058
5059 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5060 {
5061         int level;
5062         level = ndr_print_get_switch_value(ndr, r);
5063         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5064         switch (level) {
5065                 case 1:
5066                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5067                 break;
5068
5069                 case 2:
5070                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5071                 break;
5072
5073                 case 3:
5074                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5075                 break;
5076
5077                 case 4:
5078                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5079                 break;
5080
5081                 default:
5082                 break;
5083
5084         }
5085 }
5086
5087 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5088 {
5089         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5090 }
5091
5092 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5093 {
5094         if (ndr_flags & NDR_SCALARS) {
5095                 NDR_CHECK(ndr_push_align(ndr, 5));
5096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5103                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5108                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5109                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5110         }
5111         if (ndr_flags & NDR_BUFFERS) {
5112                 if (r->printer_name) {
5113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5116                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5117                 }
5118                 if (r->server_name) {
5119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5122                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5123                 }
5124                 if (r->user_name) {
5125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5129                 }
5130                 if (r->document_name) {
5131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5134                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5135                 }
5136                 if (r->data_type) {
5137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5141                 }
5142                 if (r->text_status) {
5143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5146                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5147                 }
5148         }
5149         return NDR_ERR_SUCCESS;
5150 }
5151
5152 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5153 {
5154         uint32_t _ptr_printer_name;
5155         TALLOC_CTX *_mem_save_printer_name_0;
5156         uint32_t _ptr_server_name;
5157         TALLOC_CTX *_mem_save_server_name_0;
5158         uint32_t _ptr_user_name;
5159         TALLOC_CTX *_mem_save_user_name_0;
5160         uint32_t _ptr_document_name;
5161         TALLOC_CTX *_mem_save_document_name_0;
5162         uint32_t _ptr_data_type;
5163         TALLOC_CTX *_mem_save_data_type_0;
5164         uint32_t _ptr_text_status;
5165         TALLOC_CTX *_mem_save_text_status_0;
5166         if (ndr_flags & NDR_SCALARS) {
5167                 NDR_CHECK(ndr_pull_align(ndr, 5));
5168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5170                 if (_ptr_printer_name) {
5171                         NDR_PULL_ALLOC(ndr, r->printer_name);
5172                 } else {
5173                         r->printer_name = NULL;
5174                 }
5175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5176                 if (_ptr_server_name) {
5177                         NDR_PULL_ALLOC(ndr, r->server_name);
5178                 } else {
5179                         r->server_name = NULL;
5180                 }
5181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5182                 if (_ptr_user_name) {
5183                         NDR_PULL_ALLOC(ndr, r->user_name);
5184                 } else {
5185                         r->user_name = NULL;
5186                 }
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5188                 if (_ptr_document_name) {
5189                         NDR_PULL_ALLOC(ndr, r->document_name);
5190                 } else {
5191                         r->document_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5194                 if (_ptr_data_type) {
5195                         NDR_PULL_ALLOC(ndr, r->data_type);
5196                 } else {
5197                         r->data_type = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5200                 if (_ptr_text_status) {
5201                         NDR_PULL_ALLOC(ndr, r->text_status);
5202                 } else {
5203                         r->text_status = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5207                 if (r->priority > 99) {
5208                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5209                 }
5210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5213                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5214                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5215         }
5216         if (ndr_flags & NDR_BUFFERS) {
5217                 if (r->printer_name) {
5218                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5219                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5222                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5224                         }
5225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5228                 }
5229                 if (r->server_name) {
5230                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5231                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5234                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5236                         }
5237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5240                 }
5241                 if (r->user_name) {
5242                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5243                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5246                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5247                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5248                         }
5249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5252                 }
5253                 if (r->document_name) {
5254                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5255                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5258                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5259                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5260                         }
5261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5264                 }
5265                 if (r->data_type) {
5266                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5270                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5271                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5272                         }
5273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5276                 }
5277                 if (r->text_status) {
5278                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5282                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5283                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5284                         }
5285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5288                 }
5289         }
5290         return NDR_ERR_SUCCESS;
5291 }
5292
5293 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5294 {
5295         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5296         ndr->depth++;
5297         ndr_print_uint32(ndr, "job_id", r->job_id);
5298         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5299         ndr->depth++;
5300         if (r->printer_name) {
5301                 ndr_print_string(ndr, "printer_name", r->printer_name);
5302         }
5303         ndr->depth--;
5304         ndr_print_ptr(ndr, "server_name", r->server_name);
5305         ndr->depth++;
5306         if (r->server_name) {
5307                 ndr_print_string(ndr, "server_name", r->server_name);
5308         }
5309         ndr->depth--;
5310         ndr_print_ptr(ndr, "user_name", r->user_name);
5311         ndr->depth++;
5312         if (r->user_name) {
5313                 ndr_print_string(ndr, "user_name", r->user_name);
5314         }
5315         ndr->depth--;
5316         ndr_print_ptr(ndr, "document_name", r->document_name);
5317         ndr->depth++;
5318         if (r->document_name) {
5319                 ndr_print_string(ndr, "document_name", r->document_name);
5320         }
5321         ndr->depth--;
5322         ndr_print_ptr(ndr, "data_type", r->data_type);
5323         ndr->depth++;
5324         if (r->data_type) {
5325                 ndr_print_string(ndr, "data_type", r->data_type);
5326         }
5327         ndr->depth--;
5328         ndr_print_ptr(ndr, "text_status", r->text_status);
5329         ndr->depth++;
5330         if (r->text_status) {
5331                 ndr_print_string(ndr, "text_status", r->text_status);
5332         }
5333         ndr->depth--;
5334         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5335         ndr_print_uint32(ndr, "priority", r->priority);
5336         ndr_print_uint32(ndr, "position", r->position);
5337         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5338         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5339         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5340         ndr->depth--;
5341 }
5342
5343 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5344 {
5345         if (ndr_flags & NDR_SCALARS) {
5346                 NDR_CHECK(ndr_push_align(ndr, 5));
5347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5360                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5367                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5370                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5371         }
5372         if (ndr_flags & NDR_BUFFERS) {
5373                 if (r->printer_name) {
5374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5378                 }
5379                 if (r->server_name) {
5380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5383                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5384                 }
5385                 if (r->user_name) {
5386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5387                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5390                 }
5391                 if (r->document_name) {
5392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5396                 }
5397                 if (r->notify_name) {
5398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5402                 }
5403                 if (r->data_type) {
5404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5408                 }
5409                 if (r->print_processor) {
5410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5413                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5414                 }
5415                 if (r->parameters) {
5416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5419                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5420                 }
5421                 if (r->driver_name) {
5422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5426                 }
5427                 if (r->text_status) {
5428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5432                 }
5433         }
5434         return NDR_ERR_SUCCESS;
5435 }
5436
5437 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5438 {
5439         uint32_t _ptr_printer_name;
5440         TALLOC_CTX *_mem_save_printer_name_0;
5441         uint32_t _ptr_server_name;
5442         TALLOC_CTX *_mem_save_server_name_0;
5443         uint32_t _ptr_user_name;
5444         TALLOC_CTX *_mem_save_user_name_0;
5445         uint32_t _ptr_document_name;
5446         TALLOC_CTX *_mem_save_document_name_0;
5447         uint32_t _ptr_notify_name;
5448         TALLOC_CTX *_mem_save_notify_name_0;
5449         uint32_t _ptr_data_type;
5450         TALLOC_CTX *_mem_save_data_type_0;
5451         uint32_t _ptr_print_processor;
5452         TALLOC_CTX *_mem_save_print_processor_0;
5453         uint32_t _ptr_parameters;
5454         TALLOC_CTX *_mem_save_parameters_0;
5455         uint32_t _ptr_driver_name;
5456         TALLOC_CTX *_mem_save_driver_name_0;
5457         uint32_t _ptr_text_status;
5458         TALLOC_CTX *_mem_save_text_status_0;
5459         if (ndr_flags & NDR_SCALARS) {
5460                 NDR_CHECK(ndr_pull_align(ndr, 5));
5461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5463                 if (_ptr_printer_name) {
5464                         NDR_PULL_ALLOC(ndr, r->printer_name);
5465                 } else {
5466                         r->printer_name = NULL;
5467                 }
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5469                 if (_ptr_server_name) {
5470                         NDR_PULL_ALLOC(ndr, r->server_name);
5471                 } else {
5472                         r->server_name = NULL;
5473                 }
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5475                 if (_ptr_user_name) {
5476                         NDR_PULL_ALLOC(ndr, r->user_name);
5477                 } else {
5478                         r->user_name = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5481                 if (_ptr_document_name) {
5482                         NDR_PULL_ALLOC(ndr, r->document_name);
5483                 } else {
5484                         r->document_name = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5487                 if (_ptr_notify_name) {
5488                         NDR_PULL_ALLOC(ndr, r->notify_name);
5489                 } else {
5490                         r->notify_name = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5493                 if (_ptr_data_type) {
5494                         NDR_PULL_ALLOC(ndr, r->data_type);
5495                 } else {
5496                         r->data_type = NULL;
5497                 }
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5499                 if (_ptr_print_processor) {
5500                         NDR_PULL_ALLOC(ndr, r->print_processor);
5501                 } else {
5502                         r->print_processor = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5505                 if (_ptr_parameters) {
5506                         NDR_PULL_ALLOC(ndr, r->parameters);
5507                 } else {
5508                         r->parameters = NULL;
5509                 }
5510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5511                 if (_ptr_driver_name) {
5512                         NDR_PULL_ALLOC(ndr, r->driver_name);
5513                 } else {
5514                         r->driver_name = NULL;
5515                 }
5516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5518                 if (_ptr_text_status) {
5519                         NDR_PULL_ALLOC(ndr, r->text_status);
5520                 } else {
5521                         r->text_status = NULL;
5522                 }
5523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5524                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5526                 if (r->priority > 99) {
5527                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5528                 }
5529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5534                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5538         }
5539         if (ndr_flags & NDR_BUFFERS) {
5540                 if (r->printer_name) {
5541                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5542                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5545                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5546                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5547                         }
5548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5551                 }
5552                 if (r->server_name) {
5553                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5554                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5557                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5559                         }
5560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5563                 }
5564                 if (r->user_name) {
5565                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5566                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5569                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5570                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5571                         }
5572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5575                 }
5576                 if (r->document_name) {
5577                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5578                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5581                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5582                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5583                         }
5584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5587                 }
5588                 if (r->notify_name) {
5589                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5590                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5593                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5594                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5595                         }
5596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5599                 }
5600                 if (r->data_type) {
5601                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5602                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5603                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5604                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5605                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5606                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5607                         }
5608                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5609                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5611                 }
5612                 if (r->print_processor) {
5613                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5617                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5618                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5619                         }
5620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5623                 }
5624                 if (r->parameters) {
5625                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5626                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5629                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5630                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5631                         }
5632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5635                 }
5636                 if (r->driver_name) {
5637                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5638                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5641                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5642                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5643                         }
5644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5647                 }
5648                 if (r->text_status) {
5649                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5650                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5653                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5654                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5655                         }
5656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5659                 }
5660         }
5661         return NDR_ERR_SUCCESS;
5662 }
5663
5664 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5665 {
5666         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5667         ndr->depth++;
5668         ndr_print_uint32(ndr, "job_id", r->job_id);
5669         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5670         ndr->depth++;
5671         if (r->printer_name) {
5672                 ndr_print_string(ndr, "printer_name", r->printer_name);
5673         }
5674         ndr->depth--;
5675         ndr_print_ptr(ndr, "server_name", r->server_name);
5676         ndr->depth++;
5677         if (r->server_name) {
5678                 ndr_print_string(ndr, "server_name", r->server_name);
5679         }
5680         ndr->depth--;
5681         ndr_print_ptr(ndr, "user_name", r->user_name);
5682         ndr->depth++;
5683         if (r->user_name) {
5684                 ndr_print_string(ndr, "user_name", r->user_name);
5685         }
5686         ndr->depth--;
5687         ndr_print_ptr(ndr, "document_name", r->document_name);
5688         ndr->depth++;
5689         if (r->document_name) {
5690                 ndr_print_string(ndr, "document_name", r->document_name);
5691         }
5692         ndr->depth--;
5693         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5694         ndr->depth++;
5695         if (r->notify_name) {
5696                 ndr_print_string(ndr, "notify_name", r->notify_name);
5697         }
5698         ndr->depth--;
5699         ndr_print_ptr(ndr, "data_type", r->data_type);
5700         ndr->depth++;
5701         if (r->data_type) {
5702                 ndr_print_string(ndr, "data_type", r->data_type);
5703         }
5704         ndr->depth--;
5705         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5706         ndr->depth++;
5707         if (r->print_processor) {
5708                 ndr_print_string(ndr, "print_processor", r->print_processor);
5709         }
5710         ndr->depth--;
5711         ndr_print_ptr(ndr, "parameters", r->parameters);
5712         ndr->depth++;
5713         if (r->parameters) {
5714                 ndr_print_string(ndr, "parameters", r->parameters);
5715         }
5716         ndr->depth--;
5717         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5718         ndr->depth++;
5719         if (r->driver_name) {
5720                 ndr_print_string(ndr, "driver_name", r->driver_name);
5721         }
5722         ndr->depth--;
5723         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5724         ndr_print_ptr(ndr, "text_status", r->text_status);
5725         ndr->depth++;
5726         if (r->text_status) {
5727                 ndr_print_string(ndr, "text_status", r->text_status);
5728         }
5729         ndr->depth--;
5730         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5731         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5732         ndr_print_uint32(ndr, "priority", r->priority);
5733         ndr_print_uint32(ndr, "position", r->position);
5734         ndr_print_uint32(ndr, "start_time", r->start_time);
5735         ndr_print_uint32(ndr, "until_time", r->until_time);
5736         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5737         ndr_print_uint32(ndr, "size", r->size);
5738         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5739         ndr_print_uint32(ndr, "time", r->time);
5740         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5741         ndr->depth--;
5742 }
5743
5744 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5745 {
5746         if (ndr_flags & NDR_SCALARS) {
5747                 NDR_CHECK(ndr_push_align(ndr, 5));
5748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5756                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5761                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5768                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5772                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5773         }
5774         if (ndr_flags & NDR_BUFFERS) {
5775                 if (r->printer_name) {
5776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5780                 }
5781                 if (r->server_name) {
5782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5786                 }
5787                 if (r->user_name) {
5788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5792                 }
5793                 if (r->document_name) {
5794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5798                 }
5799                 if (r->notify_name) {
5800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5804                 }
5805                 if (r->data_type) {
5806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5810                 }
5811                 if (r->print_processor) {
5812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5816                 }
5817                 if (r->parameters) {
5818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5822                 }
5823                 if (r->driver_name) {
5824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5828                 }
5829                 if (r->text_status) {
5830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5833                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5834                 }
5835         }
5836         return NDR_ERR_SUCCESS;
5837 }
5838
5839 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5840 {
5841         uint32_t _ptr_printer_name;
5842         TALLOC_CTX *_mem_save_printer_name_0;
5843         uint32_t _ptr_server_name;
5844         TALLOC_CTX *_mem_save_server_name_0;
5845         uint32_t _ptr_user_name;
5846         TALLOC_CTX *_mem_save_user_name_0;
5847         uint32_t _ptr_document_name;
5848         TALLOC_CTX *_mem_save_document_name_0;
5849         uint32_t _ptr_notify_name;
5850         TALLOC_CTX *_mem_save_notify_name_0;
5851         uint32_t _ptr_data_type;
5852         TALLOC_CTX *_mem_save_data_type_0;
5853         uint32_t _ptr_print_processor;
5854         TALLOC_CTX *_mem_save_print_processor_0;
5855         uint32_t _ptr_parameters;
5856         TALLOC_CTX *_mem_save_parameters_0;
5857         uint32_t _ptr_driver_name;
5858         TALLOC_CTX *_mem_save_driver_name_0;
5859         uint32_t _ptr_text_status;
5860         TALLOC_CTX *_mem_save_text_status_0;
5861         if (ndr_flags & NDR_SCALARS) {
5862                 NDR_CHECK(ndr_pull_align(ndr, 5));
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5865                 if (_ptr_printer_name) {
5866                         NDR_PULL_ALLOC(ndr, r->printer_name);
5867                 } else {
5868                         r->printer_name = NULL;
5869                 }
5870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5871                 if (_ptr_server_name) {
5872                         NDR_PULL_ALLOC(ndr, r->server_name);
5873                 } else {
5874                         r->server_name = NULL;
5875                 }
5876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5877                 if (_ptr_user_name) {
5878                         NDR_PULL_ALLOC(ndr, r->user_name);
5879                 } else {
5880                         r->user_name = NULL;
5881                 }
5882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5883                 if (_ptr_document_name) {
5884                         NDR_PULL_ALLOC(ndr, r->document_name);
5885                 } else {
5886                         r->document_name = NULL;
5887                 }
5888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5889                 if (_ptr_notify_name) {
5890                         NDR_PULL_ALLOC(ndr, r->notify_name);
5891                 } else {
5892                         r->notify_name = NULL;
5893                 }
5894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5895                 if (_ptr_data_type) {
5896                         NDR_PULL_ALLOC(ndr, r->data_type);
5897                 } else {
5898                         r->data_type = NULL;
5899                 }
5900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5901                 if (_ptr_print_processor) {
5902                         NDR_PULL_ALLOC(ndr, r->print_processor);
5903                 } else {
5904                         r->print_processor = NULL;
5905                 }
5906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5907                 if (_ptr_parameters) {
5908                         NDR_PULL_ALLOC(ndr, r->parameters);
5909                 } else {
5910                         r->parameters = NULL;
5911                 }
5912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5913                 if (_ptr_driver_name) {
5914                         NDR_PULL_ALLOC(ndr, r->driver_name);
5915                 } else {
5916                         r->driver_name = NULL;
5917                 }
5918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5920                 if (_ptr_text_status) {
5921                         NDR_PULL_ALLOC(ndr, r->text_status);
5922                 } else {
5923                         r->text_status = NULL;
5924                 }
5925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5926                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5928                 if (r->priority > 99) {
5929                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5930                 }
5931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5936                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5940                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5941         }
5942         if (ndr_flags & NDR_BUFFERS) {
5943                 if (r->printer_name) {
5944                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5945                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5948                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5949                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5950                         }
5951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5954                 }
5955                 if (r->server_name) {
5956                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5957                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5960                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5961                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5962                         }
5963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5966                 }
5967                 if (r->user_name) {
5968                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5972                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5973                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5978                 }
5979                 if (r->document_name) {
5980                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5981                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5984                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5985                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5986                         }
5987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5990                 }
5991                 if (r->notify_name) {
5992                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5993                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5996                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5997                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5998                         }
5999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6002                 }
6003                 if (r->data_type) {
6004                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6005                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6008                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6009                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
6010                         }
6011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6014                 }
6015                 if (r->print_processor) {
6016                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6017                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6020                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6021                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
6022                         }
6023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6026                 }
6027                 if (r->parameters) {
6028                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6032                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6033                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6034                         }
6035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6038                 }
6039                 if (r->driver_name) {
6040                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6041                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6044                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6045                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
6046                         }
6047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6050                 }
6051                 if (r->text_status) {
6052                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6053                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6056                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6057                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
6058                         }
6059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6062                 }
6063         }
6064         return NDR_ERR_SUCCESS;
6065 }
6066
6067 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6068 {
6069         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6070         ndr->depth++;
6071         ndr_print_uint32(ndr, "job_id", r->job_id);
6072         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6073         ndr->depth++;
6074         if (r->printer_name) {
6075                 ndr_print_string(ndr, "printer_name", r->printer_name);
6076         }
6077         ndr->depth--;
6078         ndr_print_ptr(ndr, "server_name", r->server_name);
6079         ndr->depth++;
6080         if (r->server_name) {
6081                 ndr_print_string(ndr, "server_name", r->server_name);
6082         }
6083         ndr->depth--;
6084         ndr_print_ptr(ndr, "user_name", r->user_name);
6085         ndr->depth++;
6086         if (r->user_name) {
6087                 ndr_print_string(ndr, "user_name", r->user_name);
6088         }
6089         ndr->depth--;
6090         ndr_print_ptr(ndr, "document_name", r->document_name);
6091         ndr->depth++;
6092         if (r->document_name) {
6093                 ndr_print_string(ndr, "document_name", r->document_name);
6094         }
6095         ndr->depth--;
6096         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6097         ndr->depth++;
6098         if (r->notify_name) {
6099                 ndr_print_string(ndr, "notify_name", r->notify_name);
6100         }
6101         ndr->depth--;
6102         ndr_print_ptr(ndr, "data_type", r->data_type);
6103         ndr->depth++;
6104         if (r->data_type) {
6105                 ndr_print_string(ndr, "data_type", r->data_type);
6106         }
6107         ndr->depth--;
6108         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6109         ndr->depth++;
6110         if (r->print_processor) {
6111                 ndr_print_string(ndr, "print_processor", r->print_processor);
6112         }
6113         ndr->depth--;
6114         ndr_print_ptr(ndr, "parameters", r->parameters);
6115         ndr->depth++;
6116         if (r->parameters) {
6117                 ndr_print_string(ndr, "parameters", r->parameters);
6118         }
6119         ndr->depth--;
6120         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6121         ndr->depth++;
6122         if (r->driver_name) {
6123                 ndr_print_string(ndr, "driver_name", r->driver_name);
6124         }
6125         ndr->depth--;
6126         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6127         ndr_print_ptr(ndr, "text_status", r->text_status);
6128         ndr->depth++;
6129         if (r->text_status) {
6130                 ndr_print_string(ndr, "text_status", r->text_status);
6131         }
6132         ndr->depth--;
6133         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6134         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6135         ndr_print_uint32(ndr, "priority", r->priority);
6136         ndr_print_uint32(ndr, "position", r->position);
6137         ndr_print_uint32(ndr, "start_time", r->start_time);
6138         ndr_print_uint32(ndr, "until_time", r->until_time);
6139         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6140         ndr_print_uint32(ndr, "size", r->size);
6141         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6142         ndr_print_uint32(ndr, "time", r->time);
6143         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6144         ndr_print_uint32(ndr, "size_high", r->size_high);
6145         ndr->depth--;
6146 }
6147
6148 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6149 {
6150         if (ndr_flags & NDR_SCALARS) {
6151                 int level = ndr_push_get_switch_value(ndr, r);
6152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6153                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6154                 switch (level) {
6155                         case 1: {
6156                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6157                         break; }
6158
6159                         case 2: {
6160                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6161                         break; }
6162
6163                         case 3: {
6164                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6165                         break; }
6166
6167                         case 4: {
6168                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6169                         break; }
6170
6171                         default: {
6172                         break; }
6173
6174                 }
6175         }
6176         if (ndr_flags & NDR_BUFFERS) {
6177                 int level = ndr_push_get_switch_value(ndr, r);
6178                 switch (level) {
6179                         case 1:
6180                                 if (r->info1) {
6181                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6182                                 }
6183                         break;
6184
6185                         case 2:
6186                                 if (r->info2) {
6187                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6188                                 }
6189                         break;
6190
6191                         case 3:
6192                                 if (r->info3) {
6193                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6194                                 }
6195                         break;
6196
6197                         case 4:
6198                                 if (r->info4) {
6199                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6200                                 }
6201                         break;
6202
6203                         default:
6204                         break;
6205
6206                 }
6207         }
6208         return NDR_ERR_SUCCESS;
6209 }
6210
6211 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6212 {
6213         int level;
6214         uint32_t _level;
6215         TALLOC_CTX *_mem_save_info1_0;
6216         TALLOC_CTX *_mem_save_info2_0;
6217         TALLOC_CTX *_mem_save_info3_0;
6218         TALLOC_CTX *_mem_save_info4_0;
6219         level = ndr_pull_get_switch_value(ndr, r);
6220         if (ndr_flags & NDR_SCALARS) {
6221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6222                 if (_level != level) {
6223                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6224                 }
6225                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6226                 switch (level) {
6227                         case 1: {
6228                                 uint32_t _ptr_info1;
6229                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6230                                 if (_ptr_info1) {
6231                                         NDR_PULL_ALLOC(ndr, r->info1);
6232                                 } else {
6233                                         r->info1 = NULL;
6234                                 }
6235                         break; }
6236
6237                         case 2: {
6238                                 uint32_t _ptr_info2;
6239                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6240                                 if (_ptr_info2) {
6241                                         NDR_PULL_ALLOC(ndr, r->info2);
6242                                 } else {
6243                                         r->info2 = NULL;
6244                                 }
6245                         break; }
6246
6247                         case 3: {
6248                                 uint32_t _ptr_info3;
6249                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6250                                 if (_ptr_info3) {
6251                                         NDR_PULL_ALLOC(ndr, r->info3);
6252                                 } else {
6253                                         r->info3 = NULL;
6254                                 }
6255                         break; }
6256
6257                         case 4: {
6258                                 uint32_t _ptr_info4;
6259                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6260                                 if (_ptr_info4) {
6261                                         NDR_PULL_ALLOC(ndr, r->info4);
6262                                 } else {
6263                                         r->info4 = NULL;
6264                                 }
6265                         break; }
6266
6267                         default: {
6268                         break; }
6269
6270                 }
6271         }
6272         if (ndr_flags & NDR_BUFFERS) {
6273                 switch (level) {
6274                         case 1:
6275                                 if (r->info1) {
6276                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6278                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6279                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6280                                 }
6281                         break;
6282
6283                         case 2:
6284                                 if (r->info2) {
6285                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6286                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6287                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6288                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6289                                 }
6290                         break;
6291
6292                         case 3:
6293                                 if (r->info3) {
6294                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6295                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6296                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6297                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6298                                 }
6299                         break;
6300
6301                         case 4:
6302                                 if (r->info4) {
6303                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6304                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6305                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6306                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6307                                 }
6308                         break;
6309
6310                         default:
6311                         break;
6312
6313                 }
6314         }
6315         return NDR_ERR_SUCCESS;
6316 }
6317
6318 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6319 {
6320         int level;
6321         level = ndr_print_get_switch_value(ndr, r);
6322         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6323         switch (level) {
6324                 case 1:
6325                         ndr_print_ptr(ndr, "info1", r->info1);
6326                         ndr->depth++;
6327                         if (r->info1) {
6328                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6329                         }
6330                         ndr->depth--;
6331                 break;
6332
6333                 case 2:
6334                         ndr_print_ptr(ndr, "info2", r->info2);
6335                         ndr->depth++;
6336                         if (r->info2) {
6337                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6338                         }
6339                         ndr->depth--;
6340                 break;
6341
6342                 case 3:
6343                         ndr_print_ptr(ndr, "info3", r->info3);
6344                         ndr->depth++;
6345                         if (r->info3) {
6346                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6347                         }
6348                         ndr->depth--;
6349                 break;
6350
6351                 case 4:
6352                         ndr_print_ptr(ndr, "info4", r->info4);
6353                         ndr->depth++;
6354                         if (r->info4) {
6355                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6356                         }
6357                         ndr->depth--;
6358                 break;
6359
6360                 default:
6361                 break;
6362
6363         }
6364 }
6365
6366 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6367 {
6368         if (ndr_flags & NDR_SCALARS) {
6369                 NDR_CHECK(ndr_push_align(ndr, 5));
6370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6371                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6372                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6373                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6374         }
6375         if (ndr_flags & NDR_BUFFERS) {
6376                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6377         }
6378         return NDR_ERR_SUCCESS;
6379 }
6380
6381 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6382 {
6383         if (ndr_flags & NDR_SCALARS) {
6384                 NDR_CHECK(ndr_pull_align(ndr, 5));
6385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6386                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6387                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6388                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6389         }
6390         if (ndr_flags & NDR_BUFFERS) {
6391                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6392         }
6393         return NDR_ERR_SUCCESS;
6394 }
6395
6396 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6397 {
6398         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6399         ndr->depth++;
6400         ndr_print_uint32(ndr, "level", r->level);
6401         ndr_print_set_switch_value(ndr, &r->info, r->level);
6402         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6403         ndr->depth--;
6404 }
6405
6406 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6407 {
6408         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6409         return NDR_ERR_SUCCESS;
6410 }
6411
6412 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6413 {
6414         uint32_t v;
6415         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6416         *r = v;
6417         return NDR_ERR_SUCCESS;
6418 }
6419
6420 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6421 {
6422         const char *val = NULL;
6423
6424         switch (r) {
6425                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6426                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6427                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6428                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6429                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6430                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6431                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6432                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6433                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6434         }
6435         ndr_print_enum(ndr, name, "ENUM", val, r);
6436 }
6437
6438 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6439 {
6440         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6441         return NDR_ERR_SUCCESS;
6442 }
6443
6444 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6445 {
6446         uint32_t v;
6447         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6448         *r = v;
6449         return NDR_ERR_SUCCESS;
6450 }
6451
6452 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6453 {
6454         const char *val = NULL;
6455
6456         switch (r) {
6457                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6458                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6459                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6460                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6461                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6462         }
6463         ndr_print_enum(ndr, name, "ENUM", val, r);
6464 }
6465
6466 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6467 {
6468         if (ndr_flags & NDR_SCALARS) {
6469                 NDR_CHECK(ndr_push_align(ndr, 5));
6470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6475                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6487                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6490                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6494                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6499                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6500         }
6501         if (ndr_flags & NDR_BUFFERS) {
6502                 if (r->servername) {
6503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6506                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6507                 }
6508                 if (r->printername) {
6509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6513                 }
6514         }
6515         return NDR_ERR_SUCCESS;
6516 }
6517
6518 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6519 {
6520         uint32_t _ptr_servername;
6521         TALLOC_CTX *_mem_save_servername_0;
6522         uint32_t _ptr_printername;
6523         TALLOC_CTX *_mem_save_printername_0;
6524         if (ndr_flags & NDR_SCALARS) {
6525                 NDR_CHECK(ndr_pull_align(ndr, 5));
6526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6527                 if (_ptr_servername) {
6528                         NDR_PULL_ALLOC(ndr, r->servername);
6529                 } else {
6530                         r->servername = NULL;
6531                 }
6532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6533                 if (_ptr_printername) {
6534                         NDR_PULL_ALLOC(ndr, r->printername);
6535                 } else {
6536                         r->printername = NULL;
6537                 }
6538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6541                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6553                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6560                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6565                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6566         }
6567         if (ndr_flags & NDR_BUFFERS) {
6568                 if (r->servername) {
6569                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6570                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6573                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6575                         }
6576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6579                 }
6580                 if (r->printername) {
6581                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6585                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6586                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6587                         }
6588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6591                 }
6592         }
6593         return NDR_ERR_SUCCESS;
6594 }
6595
6596 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6597 {
6598         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6599         ndr->depth++;
6600         ndr_print_ptr(ndr, "servername", r->servername);
6601         ndr->depth++;
6602         if (r->servername) {
6603                 ndr_print_string(ndr, "servername", r->servername);
6604         }
6605         ndr->depth--;
6606         ndr_print_ptr(ndr, "printername", r->printername);
6607         ndr->depth++;
6608         if (r->printername) {
6609                 ndr_print_string(ndr, "printername", r->printername);
6610         }
6611         ndr->depth--;
6612         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6613         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6614         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6615         ndr_print_spoolss_Time(ndr, "time", &r->time);
6616         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6617         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6618         ndr_print_uint32(ndr, "version", r->version);
6619         ndr_print_uint32(ndr, "free_build", r->free_build);
6620         ndr_print_uint32(ndr, "spooling", r->spooling);
6621         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6622         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6623         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6624         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6625         ndr_print_uint32(ndr, "job_error", r->job_error);
6626         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6627         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6628         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6629         ndr_print_uint32(ndr, "change_id", r->change_id);
6630         ndr_print_WERROR(ndr, "last_error", r->last_error);
6631         ndr_print_uint32(ndr, "status", r->status);
6632         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6633         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6634         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6635         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6636         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6637         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6638         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6639         ndr->depth--;
6640 }
6641
6642 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6643 {
6644         if (ndr_flags & NDR_SCALARS) {
6645                 NDR_CHECK(ndr_push_align(ndr, 5));
6646                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6650                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6651         }
6652         if (ndr_flags & NDR_BUFFERS) {
6653                 if (r->description) {
6654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6658                 }
6659                 if (r->name) {
6660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6664                 }
6665                 if (r->comment) {
6666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6670                 }
6671         }
6672         return NDR_ERR_SUCCESS;
6673 }
6674
6675 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6676 {
6677         uint32_t _ptr_description;
6678         TALLOC_CTX *_mem_save_description_0;
6679         uint32_t _ptr_name;
6680         TALLOC_CTX *_mem_save_name_0;
6681         uint32_t _ptr_comment;
6682         TALLOC_CTX *_mem_save_comment_0;
6683         if (ndr_flags & NDR_SCALARS) {
6684                 NDR_CHECK(ndr_pull_align(ndr, 5));
6685                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6687                 if (_ptr_description) {
6688                         NDR_PULL_ALLOC(ndr, r->description);
6689                 } else {
6690                         r->description = NULL;
6691                 }
6692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6693                 if (_ptr_name) {
6694                         NDR_PULL_ALLOC(ndr, r->name);
6695                 } else {
6696                         r->name = NULL;
6697                 }
6698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6699                 if (_ptr_comment) {
6700                         NDR_PULL_ALLOC(ndr, r->comment);
6701                 } else {
6702                         r->comment = NULL;
6703                 }
6704                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6705         }
6706         if (ndr_flags & NDR_BUFFERS) {
6707                 if (r->description) {
6708                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6709                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6712                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6713                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
6714                         }
6715                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6716                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6718                 }
6719                 if (r->name) {
6720                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6721                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6722                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6723                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6724                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6725                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
6726                         }
6727                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6728                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6730                 }
6731                 if (r->comment) {
6732                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6733                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6734                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6735                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6736                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6737                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6738                         }
6739                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6740                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6742                 }
6743         }
6744         return NDR_ERR_SUCCESS;
6745 }
6746
6747 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6748 {
6749         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6750         ndr->depth++;
6751         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6752         ndr_print_ptr(ndr, "description", r->description);
6753         ndr->depth++;
6754         if (r->description) {
6755                 ndr_print_string(ndr, "description", r->description);
6756         }
6757         ndr->depth--;
6758         ndr_print_ptr(ndr, "name", r->name);
6759         ndr->depth++;
6760         if (r->name) {
6761                 ndr_print_string(ndr, "name", r->name);
6762         }
6763         ndr->depth--;
6764         ndr_print_ptr(ndr, "comment", r->comment);
6765         ndr->depth++;
6766         if (r->comment) {
6767                 ndr_print_string(ndr, "comment", r->comment);
6768         }
6769         ndr->depth--;
6770         ndr->depth--;
6771 }
6772
6773 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6774 {
6775         if (ndr_flags & NDR_SCALARS) {
6776                 NDR_CHECK(ndr_push_align(ndr, 5));
6777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6790                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6795                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6798                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6799         }
6800         if (ndr_flags & NDR_BUFFERS) {
6801                 if (r->servername) {
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6806                 }
6807                 if (r->printername) {
6808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6811                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6812                 }
6813                 if (r->sharename) {
6814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6817                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6818                 }
6819                 if (r->portname) {
6820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6824                 }
6825                 if (r->drivername) {
6826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6830                 }
6831                 if (r->comment) {
6832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6836                 }
6837                 if (r->location) {
6838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6842                 }
6843                 if (r->devmode) {
6844                         {
6845                                 struct ndr_push *_ndr_devmode;
6846                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6847                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6848                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6849                         }
6850                 }
6851                 if (r->sepfile) {
6852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6856                 }
6857                 if (r->printprocessor) {
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6862                 }
6863                 if (r->datatype) {
6864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6868                 }
6869                 if (r->parameters) {
6870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6874                 }
6875                 if (r->secdesc) {
6876                         {
6877                                 struct ndr_push *_ndr_secdesc;
6878                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6879                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6880                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6881                         }
6882                 }
6883         }
6884         return NDR_ERR_SUCCESS;
6885 }
6886
6887 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6888 {
6889         uint32_t _ptr_servername;
6890         TALLOC_CTX *_mem_save_servername_0;
6891         uint32_t _ptr_printername;
6892         TALLOC_CTX *_mem_save_printername_0;
6893         uint32_t _ptr_sharename;
6894         TALLOC_CTX *_mem_save_sharename_0;
6895         uint32_t _ptr_portname;
6896         TALLOC_CTX *_mem_save_portname_0;
6897         uint32_t _ptr_drivername;
6898         TALLOC_CTX *_mem_save_drivername_0;
6899         uint32_t _ptr_comment;
6900         TALLOC_CTX *_mem_save_comment_0;
6901         uint32_t _ptr_location;
6902         TALLOC_CTX *_mem_save_location_0;
6903         uint32_t _ptr_devmode;
6904         TALLOC_CTX *_mem_save_devmode_0;
6905         uint32_t _ptr_sepfile;
6906         TALLOC_CTX *_mem_save_sepfile_0;
6907         uint32_t _ptr_printprocessor;
6908         TALLOC_CTX *_mem_save_printprocessor_0;
6909         uint32_t _ptr_datatype;
6910         TALLOC_CTX *_mem_save_datatype_0;
6911         uint32_t _ptr_parameters;
6912         TALLOC_CTX *_mem_save_parameters_0;
6913         uint32_t _ptr_secdesc;
6914         TALLOC_CTX *_mem_save_secdesc_0;
6915         if (ndr_flags & NDR_SCALARS) {
6916                 NDR_CHECK(ndr_pull_align(ndr, 5));
6917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6918                 if (_ptr_servername) {
6919                         NDR_PULL_ALLOC(ndr, r->servername);
6920                 } else {
6921                         r->servername = NULL;
6922                 }
6923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6924                 if (_ptr_printername) {
6925                         NDR_PULL_ALLOC(ndr, r->printername);
6926                 } else {
6927                         r->printername = NULL;
6928                 }
6929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6930                 if (_ptr_sharename) {
6931                         NDR_PULL_ALLOC(ndr, r->sharename);
6932                 } else {
6933                         r->sharename = NULL;
6934                 }
6935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6936                 if (_ptr_portname) {
6937                         NDR_PULL_ALLOC(ndr, r->portname);
6938                 } else {
6939                         r->portname = NULL;
6940                 }
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6942                 if (_ptr_drivername) {
6943                         NDR_PULL_ALLOC(ndr, r->drivername);
6944                 } else {
6945                         r->drivername = NULL;
6946                 }
6947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6948                 if (_ptr_comment) {
6949                         NDR_PULL_ALLOC(ndr, r->comment);
6950                 } else {
6951                         r->comment = NULL;
6952                 }
6953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6954                 if (_ptr_location) {
6955                         NDR_PULL_ALLOC(ndr, r->location);
6956                 } else {
6957                         r->location = NULL;
6958                 }
6959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6960                 if (_ptr_devmode) {
6961                         NDR_PULL_ALLOC(ndr, r->devmode);
6962                 } else {
6963                         r->devmode = NULL;
6964                 }
6965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6966                 if (_ptr_sepfile) {
6967                         NDR_PULL_ALLOC(ndr, r->sepfile);
6968                 } else {
6969                         r->sepfile = NULL;
6970                 }
6971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6972                 if (_ptr_printprocessor) {
6973                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6974                 } else {
6975                         r->printprocessor = NULL;
6976                 }
6977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6978                 if (_ptr_datatype) {
6979                         NDR_PULL_ALLOC(ndr, r->datatype);
6980                 } else {
6981                         r->datatype = NULL;
6982                 }
6983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6984                 if (_ptr_parameters) {
6985                         NDR_PULL_ALLOC(ndr, r->parameters);
6986                 } else {
6987                         r->parameters = NULL;
6988                 }
6989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6990                 if (_ptr_secdesc) {
6991                         NDR_PULL_ALLOC(ndr, r->secdesc);
6992                 } else {
6993                         r->secdesc = NULL;
6994                 }
6995                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6997                 if (r->priority > 99) {
6998                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6999                 }
7000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7003                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7006                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7007         }
7008         if (ndr_flags & NDR_BUFFERS) {
7009                 if (r->servername) {
7010                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7011                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7014                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
7016                         }
7017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7020                 }
7021                 if (r->printername) {
7022                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7023                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7026                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7027                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7028                         }
7029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7032                 }
7033                 if (r->sharename) {
7034                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7038                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7039                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
7040                         }
7041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7044                 }
7045                 if (r->portname) {
7046                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7047                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7050                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7051                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7052                         }
7053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7056                 }
7057                 if (r->drivername) {
7058                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7062                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7068                 }
7069                 if (r->comment) {
7070                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7071                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7074                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7075                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
7076                         }
7077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7080                 }
7081                 if (r->location) {
7082                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7083                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7086                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7087                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
7088                         }
7089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7092                 }
7093                 if (r->devmode) {
7094                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
7095                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
7096                         {
7097                                 struct ndr_pull *_ndr_devmode;
7098                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
7099                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
7100                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
7101                         }
7102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
7103                 }
7104                 if (r->sepfile) {
7105                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7106                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7109                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7110                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
7111                         }
7112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7115                 }
7116                 if (r->printprocessor) {
7117                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7118                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7121                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7122                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
7123                         }
7124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7127                 }
7128                 if (r->datatype) {
7129                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7130                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7133                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7134                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
7135                         }
7136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7139                 }
7140                 if (r->parameters) {
7141                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7142                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7145                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7146                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
7147                         }
7148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7151                 }
7152                 if (r->secdesc) {
7153                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
7154                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
7155                         {
7156                                 struct ndr_pull *_ndr_secdesc;
7157                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
7158                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
7159                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
7160                         }
7161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
7162                 }
7163         }
7164         return NDR_ERR_SUCCESS;
7165 }
7166
7167 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7168 {
7169         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7170         ndr->depth++;
7171         ndr_print_ptr(ndr, "servername", r->servername);
7172         ndr->depth++;
7173         if (r->servername) {
7174                 ndr_print_string(ndr, "servername", r->servername);
7175         }
7176         ndr->depth--;
7177         ndr_print_ptr(ndr, "printername", r->printername);
7178         ndr->depth++;
7179         if (r->printername) {
7180                 ndr_print_string(ndr, "printername", r->printername);
7181         }
7182         ndr->depth--;
7183         ndr_print_ptr(ndr, "sharename", r->sharename);
7184         ndr->depth++;
7185         if (r->sharename) {
7186                 ndr_print_string(ndr, "sharename", r->sharename);
7187         }
7188         ndr->depth--;
7189         ndr_print_ptr(ndr, "portname", r->portname);
7190         ndr->depth++;
7191         if (r->portname) {
7192                 ndr_print_string(ndr, "portname", r->portname);
7193         }
7194         ndr->depth--;
7195         ndr_print_ptr(ndr, "drivername", r->drivername);
7196         ndr->depth++;
7197         if (r->drivername) {
7198                 ndr_print_string(ndr, "drivername", r->drivername);
7199         }
7200         ndr->depth--;
7201         ndr_print_ptr(ndr, "comment", r->comment);
7202         ndr->depth++;
7203         if (r->comment) {
7204                 ndr_print_string(ndr, "comment", r->comment);
7205         }
7206         ndr->depth--;
7207         ndr_print_ptr(ndr, "location", r->location);
7208         ndr->depth++;
7209         if (r->location) {
7210                 ndr_print_string(ndr, "location", r->location);
7211         }
7212         ndr->depth--;
7213         ndr_print_ptr(ndr, "devmode", r->devmode);
7214         ndr->depth++;
7215         if (r->devmode) {
7216                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
7217         }
7218         ndr->depth--;
7219         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7220         ndr->depth++;
7221         if (r->sepfile) {
7222                 ndr_print_string(ndr, "sepfile", r->sepfile);
7223         }
7224         ndr->depth--;
7225         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7226         ndr->depth++;
7227         if (r->printprocessor) {
7228                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7229         }
7230         ndr->depth--;
7231         ndr_print_ptr(ndr, "datatype", r->datatype);
7232         ndr->depth++;
7233         if (r->datatype) {
7234                 ndr_print_string(ndr, "datatype", r->datatype);
7235         }
7236         ndr->depth--;
7237         ndr_print_ptr(ndr, "parameters", r->parameters);
7238         ndr->depth++;
7239         if (r->parameters) {
7240                 ndr_print_string(ndr, "parameters", r->parameters);
7241         }
7242         ndr->depth--;
7243         ndr_print_ptr(ndr, "secdesc", r->secdesc);
7244         ndr->depth++;
7245         if (r->secdesc) {
7246                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
7247         }
7248         ndr->depth--;
7249         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7250         ndr_print_uint32(ndr, "priority", r->priority);
7251         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7252         ndr_print_uint32(ndr, "starttime", r->starttime);
7253         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7254         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7255         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7256         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7257         ndr->depth--;
7258 }
7259
7260 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7261 {
7262         if (ndr_flags & NDR_SCALARS) {
7263                 NDR_CHECK(ndr_push_align(ndr, 4));
7264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7265                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7266         }
7267         if (ndr_flags & NDR_BUFFERS) {
7268         }
7269         return NDR_ERR_SUCCESS;
7270 }
7271
7272 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7273 {
7274         if (ndr_flags & NDR_SCALARS) {
7275                 NDR_CHECK(ndr_pull_align(ndr, 4));
7276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7277                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7278         }
7279         if (ndr_flags & NDR_BUFFERS) {
7280         }
7281         return NDR_ERR_SUCCESS;
7282 }
7283
7284 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7285 {
7286         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7287         ndr->depth++;
7288         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7289         ndr->depth--;
7290 }
7291
7292 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7293 {
7294         if (ndr_flags & NDR_SCALARS) {
7295                 NDR_CHECK(ndr_push_align(ndr, 5));
7296                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7298                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7299                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7300         }
7301         if (ndr_flags & NDR_BUFFERS) {
7302                 if (r->printername) {
7303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7307                 }
7308                 if (r->servername) {
7309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7312                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7313                 }
7314         }
7315         return NDR_ERR_SUCCESS;
7316 }
7317
7318 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7319 {
7320         uint32_t _ptr_printername;
7321         TALLOC_CTX *_mem_save_printername_0;
7322         uint32_t _ptr_servername;
7323         TALLOC_CTX *_mem_save_servername_0;
7324         if (ndr_flags & NDR_SCALARS) {
7325                 NDR_CHECK(ndr_pull_align(ndr, 5));
7326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7327                 if (_ptr_printername) {
7328                         NDR_PULL_ALLOC(ndr, r->printername);
7329                 } else {
7330                         r->printername = NULL;
7331                 }
7332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7333                 if (_ptr_servername) {
7334                         NDR_PULL_ALLOC(ndr, r->servername);
7335                 } else {
7336                         r->servername = NULL;
7337                 }
7338                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7339                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342                 if (r->printername) {
7343                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7344                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7347                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7353                 }
7354                 if (r->servername) {
7355                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7356                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7357                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7358                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7359                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7360                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
7361                         }
7362                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7363                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7365                 }
7366         }
7367         return NDR_ERR_SUCCESS;
7368 }
7369
7370 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7371 {
7372         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7373         ndr->depth++;
7374         ndr_print_ptr(ndr, "printername", r->printername);
7375         ndr->depth++;
7376         if (r->printername) {
7377                 ndr_print_string(ndr, "printername", r->printername);
7378         }
7379         ndr->depth--;
7380         ndr_print_ptr(ndr, "servername", r->servername);
7381         ndr->depth++;
7382         if (r->servername) {
7383                 ndr_print_string(ndr, "servername", r->servername);
7384         }
7385         ndr->depth--;
7386         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7387         ndr->depth--;
7388 }
7389
7390 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7391 {
7392         if (ndr_flags & NDR_SCALARS) {
7393                 NDR_CHECK(ndr_push_align(ndr, 5));
7394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7396                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7399                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7400         }
7401         if (ndr_flags & NDR_BUFFERS) {
7402                 if (r->printername) {
7403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7407                 }
7408                 if (r->portname) {
7409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7413                 }
7414         }
7415         return NDR_ERR_SUCCESS;
7416 }
7417
7418 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7419 {
7420         uint32_t _ptr_printername;
7421         TALLOC_CTX *_mem_save_printername_0;
7422         uint32_t _ptr_portname;
7423         TALLOC_CTX *_mem_save_portname_0;
7424         if (ndr_flags & NDR_SCALARS) {
7425                 NDR_CHECK(ndr_pull_align(ndr, 5));
7426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7427                 if (_ptr_printername) {
7428                         NDR_PULL_ALLOC(ndr, r->printername);
7429                 } else {
7430                         r->printername = NULL;
7431                 }
7432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7433                 if (_ptr_portname) {
7434                         NDR_PULL_ALLOC(ndr, r->portname);
7435                 } else {
7436                         r->portname = NULL;
7437                 }
7438                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7441                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7442         }
7443         if (ndr_flags & NDR_BUFFERS) {
7444                 if (r->printername) {
7445                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7446                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7449                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7450                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7451                         }
7452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7455                 }
7456                 if (r->portname) {
7457                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7458                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7459                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7460                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7461                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7462                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7463                         }
7464                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7465                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7467                 }
7468         }
7469         return NDR_ERR_SUCCESS;
7470 }
7471
7472 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7473 {
7474         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7475         ndr->depth++;
7476         ndr_print_ptr(ndr, "printername", r->printername);
7477         ndr->depth++;
7478         if (r->printername) {
7479                 ndr_print_string(ndr, "printername", r->printername);
7480         }
7481         ndr->depth--;
7482         ndr_print_ptr(ndr, "portname", r->portname);
7483         ndr->depth++;
7484         if (r->portname) {
7485                 ndr_print_string(ndr, "portname", r->portname);
7486         }
7487         ndr->depth--;
7488         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7489         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7490         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7491         ndr->depth--;
7492 }
7493
7494 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7495 {
7496         if (ndr_flags & NDR_SCALARS) {
7497                 NDR_CHECK(ndr_push_align(ndr, 4));
7498                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7499                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7500         }
7501         if (ndr_flags & NDR_BUFFERS) {
7502         }
7503         return NDR_ERR_SUCCESS;
7504 }
7505
7506 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7507 {
7508         if (ndr_flags & NDR_SCALARS) {
7509                 NDR_CHECK(ndr_pull_align(ndr, 4));
7510                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7512         }
7513         if (ndr_flags & NDR_BUFFERS) {
7514         }
7515         return NDR_ERR_SUCCESS;
7516 }
7517
7518 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7519 {
7520         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7521         ndr->depth++;
7522         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7523         ndr->depth--;
7524 }
7525
7526 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7527 {
7528         if (ndr_flags & NDR_SCALARS) {
7529                 NDR_CHECK(ndr_push_align(ndr, 5));
7530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7531                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7532                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7533         }
7534         if (ndr_flags & NDR_BUFFERS) {
7535                 if (r->guid) {
7536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7538                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7540                 }
7541         }
7542         return NDR_ERR_SUCCESS;
7543 }
7544
7545 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7546 {
7547         uint32_t _ptr_guid;
7548         TALLOC_CTX *_mem_save_guid_0;
7549         if (ndr_flags & NDR_SCALARS) {
7550                 NDR_CHECK(ndr_pull_align(ndr, 5));
7551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7552                 if (_ptr_guid) {
7553                         NDR_PULL_ALLOC(ndr, r->guid);
7554                 } else {
7555                         r->guid = NULL;
7556                 }
7557                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7558                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7559         }
7560         if (ndr_flags & NDR_BUFFERS) {
7561                 if (r->guid) {
7562                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7563                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7566                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
7568                         }
7569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7572                 }
7573         }
7574         return NDR_ERR_SUCCESS;
7575 }
7576
7577 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7578 {
7579         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7580         ndr->depth++;
7581         ndr_print_ptr(ndr, "guid", r->guid);
7582         ndr->depth++;
7583         if (r->guid) {
7584                 ndr_print_string(ndr, "guid", r->guid);
7585         }
7586         ndr->depth--;
7587         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7588         ndr->depth--;
7589 }
7590
7591 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7592 {
7593         if (ndr_flags & NDR_SCALARS) {
7594                 int level = ndr_push_get_switch_value(ndr, r);
7595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7596                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7597                 switch (level) {
7598                         case 0: {
7599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7600                         break; }
7601
7602                         case 1: {
7603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7604                         break; }
7605
7606                         case 2: {
7607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7608                         break; }
7609
7610                         case 3: {
7611                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7612                         break; }
7613
7614                         case 4: {
7615                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7616                         break; }
7617
7618                         case 5: {
7619                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7620                         break; }
7621
7622                         case 6: {
7623                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7624                         break; }
7625
7626                         case 7: {
7627                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7628                         break; }
7629
7630                         case 8: {
7631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7632                         break; }
7633
7634                         case 9: {
7635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7636                         break; }
7637
7638                         default: {
7639                         break; }
7640
7641                 }
7642         }
7643         if (ndr_flags & NDR_BUFFERS) {
7644                 int level = ndr_push_get_switch_value(ndr, r);
7645                 switch (level) {
7646                         case 0:
7647                                 if (r->info0) {
7648                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7649                                 }
7650                         break;
7651
7652                         case 1:
7653                                 if (r->info1) {
7654                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7655                                 }
7656                         break;
7657
7658                         case 2:
7659                                 if (r->info2) {
7660                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7661                                 }
7662                         break;
7663
7664                         case 3:
7665                                 if (r->info3) {
7666                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7667                                 }
7668                         break;
7669
7670                         case 4:
7671                                 if (r->info4) {
7672                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7673                                 }
7674                         break;
7675
7676                         case 5:
7677                                 if (r->info5) {
7678                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7679                                 }
7680                         break;
7681
7682                         case 6:
7683                                 if (r->info6) {
7684                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7685                                 }
7686                         break;
7687
7688                         case 7:
7689                                 if (r->info7) {
7690                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7691                                 }
7692                         break;
7693
7694                         case 8:
7695                                 if (r->info8) {
7696                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7697                                 }
7698                         break;
7699
7700                         case 9:
7701                                 if (r->info9) {
7702                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7703                                 }
7704                         break;
7705
7706                         default:
7707                         break;
7708
7709                 }
7710         }
7711         return NDR_ERR_SUCCESS;
7712 }
7713
7714 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7715 {
7716         int level;
7717         uint32_t _level;
7718         TALLOC_CTX *_mem_save_info0_0;
7719         TALLOC_CTX *_mem_save_info1_0;
7720         TALLOC_CTX *_mem_save_info2_0;
7721         TALLOC_CTX *_mem_save_info3_0;
7722         TALLOC_CTX *_mem_save_info4_0;
7723         TALLOC_CTX *_mem_save_info5_0;
7724         TALLOC_CTX *_mem_save_info6_0;
7725         TALLOC_CTX *_mem_save_info7_0;
7726         TALLOC_CTX *_mem_save_info8_0;
7727         TALLOC_CTX *_mem_save_info9_0;
7728         level = ndr_pull_get_switch_value(ndr, r);
7729         if (ndr_flags & NDR_SCALARS) {
7730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7731                 if (_level != level) {
7732                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7733                 }
7734                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7735                 switch (level) {
7736                         case 0: {
7737                                 uint32_t _ptr_info0;
7738                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7739                                 if (_ptr_info0) {
7740                                         NDR_PULL_ALLOC(ndr, r->info0);
7741                                 } else {
7742                                         r->info0 = NULL;
7743                                 }
7744                         break; }
7745
7746                         case 1: {
7747                                 uint32_t _ptr_info1;
7748                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7749                                 if (_ptr_info1) {
7750                                         NDR_PULL_ALLOC(ndr, r->info1);
7751                                 } else {
7752                                         r->info1 = NULL;
7753                                 }
7754                         break; }
7755
7756                         case 2: {
7757                                 uint32_t _ptr_info2;
7758                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7759                                 if (_ptr_info2) {
7760                                         NDR_PULL_ALLOC(ndr, r->info2);
7761                                 } else {
7762                                         r->info2 = NULL;
7763                                 }
7764                         break; }
7765
7766                         case 3: {
7767                                 uint32_t _ptr_info3;
7768                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7769                                 if (_ptr_info3) {
7770                                         NDR_PULL_ALLOC(ndr, r->info3);
7771                                 } else {
7772                                         r->info3 = NULL;
7773                                 }
7774                         break; }
7775
7776                         case 4: {
7777                                 uint32_t _ptr_info4;
7778                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7779                                 if (_ptr_info4) {
7780                                         NDR_PULL_ALLOC(ndr, r->info4);
7781                                 } else {
7782                                         r->info4 = NULL;
7783                                 }
7784                         break; }
7785
7786                         case 5: {
7787                                 uint32_t _ptr_info5;
7788                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7789                                 if (_ptr_info5) {
7790                                         NDR_PULL_ALLOC(ndr, r->info5);
7791                                 } else {
7792                                         r->info5 = NULL;
7793                                 }
7794                         break; }
7795
7796                         case 6: {
7797                                 uint32_t _ptr_info6;
7798                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7799                                 if (_ptr_info6) {
7800                                         NDR_PULL_ALLOC(ndr, r->info6);
7801                                 } else {
7802                                         r->info6 = NULL;
7803                                 }
7804                         break; }
7805
7806                         case 7: {
7807                                 uint32_t _ptr_info7;
7808                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7809                                 if (_ptr_info7) {
7810                                         NDR_PULL_ALLOC(ndr, r->info7);
7811                                 } else {
7812                                         r->info7 = NULL;
7813                                 }
7814                         break; }
7815
7816                         case 8: {
7817                                 uint32_t _ptr_info8;
7818                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7819                                 if (_ptr_info8) {
7820                                         NDR_PULL_ALLOC(ndr, r->info8);
7821                                 } else {
7822                                         r->info8 = NULL;
7823                                 }
7824                         break; }
7825
7826                         case 9: {
7827                                 uint32_t _ptr_info9;
7828                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7829                                 if (_ptr_info9) {
7830                                         NDR_PULL_ALLOC(ndr, r->info9);
7831                                 } else {
7832                                         r->info9 = NULL;
7833                                 }
7834                         break; }
7835
7836                         default: {
7837                         break; }
7838
7839                 }
7840         }
7841         if (ndr_flags & NDR_BUFFERS) {
7842                 switch (level) {
7843                         case 0:
7844                                 if (r->info0) {
7845                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7846                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7847                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7848                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7849                                 }
7850                         break;
7851
7852                         case 1:
7853                                 if (r->info1) {
7854                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7855                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7856                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7857                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7858                                 }
7859                         break;
7860
7861                         case 2:
7862                                 if (r->info2) {
7863                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7864                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7865                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7866                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7867                                 }
7868                         break;
7869
7870                         case 3:
7871                                 if (r->info3) {
7872                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7873                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7874                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7875                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7876                                 }
7877                         break;
7878
7879                         case 4:
7880                                 if (r->info4) {
7881                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7882                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7883                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7884                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7885                                 }
7886                         break;
7887
7888                         case 5:
7889                                 if (r->info5) {
7890                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7891                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7892                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7893                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7894                                 }
7895                         break;
7896
7897                         case 6:
7898                                 if (r->info6) {
7899                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7900                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7901                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7902                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7903                                 }
7904                         break;
7905
7906                         case 7:
7907                                 if (r->info7) {
7908                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7909                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7910                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7911                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7912                                 }
7913                         break;
7914
7915                         case 8:
7916                                 if (r->info8) {
7917                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7918                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7919                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7920                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7921                                 }
7922                         break;
7923
7924                         case 9:
7925                                 if (r->info9) {
7926                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7927                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7928                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7929                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7930                                 }
7931                         break;
7932
7933                         default:
7934                         break;
7935
7936                 }
7937         }
7938         return NDR_ERR_SUCCESS;
7939 }
7940
7941 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7942 {
7943         int level;
7944         level = ndr_print_get_switch_value(ndr, r);
7945         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7946         switch (level) {
7947                 case 0:
7948                         ndr_print_ptr(ndr, "info0", r->info0);
7949                         ndr->depth++;
7950                         if (r->info0) {
7951                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7952                         }
7953                         ndr->depth--;
7954                 break;
7955
7956                 case 1:
7957                         ndr_print_ptr(ndr, "info1", r->info1);
7958                         ndr->depth++;
7959                         if (r->info1) {
7960                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7961                         }
7962                         ndr->depth--;
7963                 break;
7964
7965                 case 2:
7966                         ndr_print_ptr(ndr, "info2", r->info2);
7967                         ndr->depth++;
7968                         if (r->info2) {
7969                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7970                         }
7971                         ndr->depth--;
7972                 break;
7973
7974                 case 3:
7975                         ndr_print_ptr(ndr, "info3", r->info3);
7976                         ndr->depth++;
7977                         if (r->info3) {
7978                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7979                         }
7980                         ndr->depth--;
7981                 break;
7982
7983                 case 4:
7984                         ndr_print_ptr(ndr, "info4", r->info4);
7985                         ndr->depth++;
7986                         if (r->info4) {
7987                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7988                         }
7989                         ndr->depth--;
7990                 break;
7991
7992                 case 5:
7993                         ndr_print_ptr(ndr, "info5", r->info5);
7994                         ndr->depth++;
7995                         if (r->info5) {
7996                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7997                         }
7998                         ndr->depth--;
7999                 break;
8000
8001                 case 6:
8002                         ndr_print_ptr(ndr, "info6", r->info6);
8003                         ndr->depth++;
8004                         if (r->info6) {
8005                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8006                         }
8007                         ndr->depth--;
8008                 break;
8009
8010                 case 7:
8011                         ndr_print_ptr(ndr, "info7", r->info7);
8012                         ndr->depth++;
8013                         if (r->info7) {
8014                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8015                         }
8016                         ndr->depth--;
8017                 break;
8018
8019                 case 8:
8020                         ndr_print_ptr(ndr, "info8", r->info8);
8021                         ndr->depth++;
8022                         if (r->info8) {
8023                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
8024                         }
8025                         ndr->depth--;
8026                 break;
8027
8028                 case 9:
8029                         ndr_print_ptr(ndr, "info9", r->info9);
8030                         ndr->depth++;
8031                         if (r->info9) {
8032                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
8033                         }
8034                         ndr->depth--;
8035                 break;
8036
8037                 default:
8038                 break;
8039
8040         }
8041 }
8042
8043 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8044 {
8045         if (ndr_flags & NDR_SCALARS) {
8046                 NDR_CHECK(ndr_push_align(ndr, 5));
8047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8048                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8049                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8050                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8051         }
8052         if (ndr_flags & NDR_BUFFERS) {
8053                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8054         }
8055         return NDR_ERR_SUCCESS;
8056 }
8057
8058 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8059 {
8060         if (ndr_flags & NDR_SCALARS) {
8061                 NDR_CHECK(ndr_pull_align(ndr, 5));
8062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8063                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8064                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8065                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8066         }
8067         if (ndr_flags & NDR_BUFFERS) {
8068                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8069         }
8070         return NDR_ERR_SUCCESS;
8071 }
8072
8073 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8074 {
8075         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8076         ndr->depth++;
8077         ndr_print_uint32(ndr, "level", r->level);
8078         ndr_print_set_switch_value(ndr, &r->info, r->level);
8079         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8080         ndr->depth--;
8081 }
8082
8083 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8084 {
8085         if (ndr_flags & NDR_SCALARS) {
8086                 NDR_CHECK(ndr_push_align(ndr, 4));
8087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8088                 {
8089                         uint32_t _flags_save_string_array = ndr->flags;
8090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8091                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8092                         ndr->flags = _flags_save_string_array;
8093                 }
8094                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8095         }
8096         if (ndr_flags & NDR_BUFFERS) {
8097         }
8098         return NDR_ERR_SUCCESS;
8099 }
8100
8101 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8102 {
8103         if (ndr_flags & NDR_SCALARS) {
8104                 NDR_CHECK(ndr_pull_align(ndr, 4));
8105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8106                 {
8107                         uint32_t _flags_save_string_array = ndr->flags;
8108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8109                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8110                         ndr->flags = _flags_save_string_array;
8111                 }
8112                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8113         }
8114         if (ndr_flags & NDR_BUFFERS) {
8115         }
8116         return NDR_ERR_SUCCESS;
8117 }
8118
8119 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8120 {
8121         ndr_print_struct(ndr, name, "spoolss_StringArray");
8122         ndr->depth++;
8123         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
8124         ndr_print_string_array(ndr, "string", r->string);
8125         ndr->depth--;
8126 }
8127
8128 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8129 {
8130         if (ndr_flags & NDR_SCALARS) {
8131                 NDR_CHECK(ndr_push_align(ndr, 5));
8132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8133                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8134         }
8135         if (ndr_flags & NDR_BUFFERS) {
8136                 if (r->driver_name) {
8137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8141                 }
8142         }
8143         return NDR_ERR_SUCCESS;
8144 }
8145
8146 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8147 {
8148         uint32_t _ptr_driver_name;
8149         TALLOC_CTX *_mem_save_driver_name_0;
8150         if (ndr_flags & NDR_SCALARS) {
8151                 NDR_CHECK(ndr_pull_align(ndr, 5));
8152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8153                 if (_ptr_driver_name) {
8154                         NDR_PULL_ALLOC(ndr, r->driver_name);
8155                 } else {
8156                         r->driver_name = NULL;
8157                 }
8158                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8159         }
8160         if (ndr_flags & NDR_BUFFERS) {
8161                 if (r->driver_name) {
8162                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8163                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8166                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8167                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8168                         }
8169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8172                 }
8173         }
8174         return NDR_ERR_SUCCESS;
8175 }
8176
8177 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8178 {
8179         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8180         ndr->depth++;
8181         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8182         ndr->depth++;
8183         if (r->driver_name) {
8184                 ndr_print_string(ndr, "driver_name", r->driver_name);
8185         }
8186         ndr->depth--;
8187         ndr->depth--;
8188 }
8189
8190 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8191 {
8192         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8193         return NDR_ERR_SUCCESS;
8194 }
8195
8196 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8197 {
8198         uint32_t v;
8199         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8200         *r = v;
8201         return NDR_ERR_SUCCESS;
8202 }
8203
8204 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8205 {
8206         const char *val = NULL;
8207
8208         switch (r) {
8209                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8210                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8211                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8212                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8213         }
8214         ndr_print_enum(ndr, name, "ENUM", val, r);
8215 }
8216
8217 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8218 {
8219         if (ndr_flags & NDR_SCALARS) {
8220                 NDR_CHECK(ndr_push_align(ndr, 5));
8221                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8224                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8225                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8227                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8228         }
8229         if (ndr_flags & NDR_BUFFERS) {
8230                 if (r->driver_name) {
8231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8234                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8235                 }
8236                 if (r->architecture) {
8237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8240                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8241                 }
8242                 if (r->driver_path) {
8243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8246                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8247                 }
8248                 if (r->data_file) {
8249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8253                 }
8254                 if (r->config_file) {
8255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8258                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8259                 }
8260         }
8261         return NDR_ERR_SUCCESS;
8262 }
8263
8264 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8265 {
8266         uint32_t _ptr_driver_name;
8267         TALLOC_CTX *_mem_save_driver_name_0;
8268         uint32_t _ptr_architecture;
8269         TALLOC_CTX *_mem_save_architecture_0;
8270         uint32_t _ptr_driver_path;
8271         TALLOC_CTX *_mem_save_driver_path_0;
8272         uint32_t _ptr_data_file;
8273         TALLOC_CTX *_mem_save_data_file_0;
8274         uint32_t _ptr_config_file;
8275         TALLOC_CTX *_mem_save_config_file_0;
8276         if (ndr_flags & NDR_SCALARS) {
8277                 NDR_CHECK(ndr_pull_align(ndr, 5));
8278                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8280                 if (_ptr_driver_name) {
8281                         NDR_PULL_ALLOC(ndr, r->driver_name);
8282                 } else {
8283                         r->driver_name = NULL;
8284                 }
8285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8286                 if (_ptr_architecture) {
8287                         NDR_PULL_ALLOC(ndr, r->architecture);
8288                 } else {
8289                         r->architecture = NULL;
8290                 }
8291                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8292                 if (_ptr_driver_path) {
8293                         NDR_PULL_ALLOC(ndr, r->driver_path);
8294                 } else {
8295                         r->driver_path = NULL;
8296                 }
8297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8298                 if (_ptr_data_file) {
8299                         NDR_PULL_ALLOC(ndr, r->data_file);
8300                 } else {
8301                         r->data_file = NULL;
8302                 }
8303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8304                 if (_ptr_config_file) {
8305                         NDR_PULL_ALLOC(ndr, r->config_file);
8306                 } else {
8307                         r->config_file = NULL;
8308                 }
8309                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8310         }
8311         if (ndr_flags & NDR_BUFFERS) {
8312                 if (r->driver_name) {
8313                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8314                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8317                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8318                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8319                         }
8320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8323                 }
8324                 if (r->architecture) {
8325                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8326                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8329                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8330                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8331                         }
8332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8335                 }
8336                 if (r->driver_path) {
8337                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8338                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8339                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8340                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8341                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8342                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8343                         }
8344                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8345                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8347                 }
8348                 if (r->data_file) {
8349                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8350                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8353                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8354                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8355                         }
8356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8357                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8359                 }
8360                 if (r->config_file) {
8361                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8362                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8363                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8364                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8365                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8366                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8367                         }
8368                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8369                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8371                 }
8372         }
8373         return NDR_ERR_SUCCESS;
8374 }
8375
8376 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8377 {
8378         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8379         ndr->depth++;
8380         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8381         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8382         ndr->depth++;
8383         if (r->driver_name) {
8384                 ndr_print_string(ndr, "driver_name", r->driver_name);
8385         }
8386         ndr->depth--;
8387         ndr_print_ptr(ndr, "architecture", r->architecture);
8388         ndr->depth++;
8389         if (r->architecture) {
8390                 ndr_print_string(ndr, "architecture", r->architecture);
8391         }
8392         ndr->depth--;
8393         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8394         ndr->depth++;
8395         if (r->driver_path) {
8396                 ndr_print_string(ndr, "driver_path", r->driver_path);
8397         }
8398         ndr->depth--;
8399         ndr_print_ptr(ndr, "data_file", r->data_file);
8400         ndr->depth++;
8401         if (r->data_file) {
8402                 ndr_print_string(ndr, "data_file", r->data_file);
8403         }
8404         ndr->depth--;
8405         ndr_print_ptr(ndr, "config_file", r->config_file);
8406         ndr->depth++;
8407         if (r->config_file) {
8408                 ndr_print_string(ndr, "config_file", r->config_file);
8409         }
8410         ndr->depth--;
8411         ndr->depth--;
8412 }
8413
8414 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8415 {
8416         if (ndr_flags & NDR_SCALARS) {
8417                 NDR_CHECK(ndr_push_align(ndr, 5));
8418                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8429                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8430         }
8431         if (ndr_flags & NDR_BUFFERS) {
8432                 if (r->driver_name) {
8433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8436                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8437                 }
8438                 if (r->architecture) {
8439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8442                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8443                 }
8444                 if (r->driver_path) {
8445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8446                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8447                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8448                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8449                 }
8450                 if (r->data_file) {
8451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8454                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8455                 }
8456                 if (r->config_file) {
8457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8461                 }
8462                 if (r->help_file) {
8463                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8464                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8466                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8467                 }
8468                 if (r->monitor_name) {
8469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8472                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8473                 }
8474                 if (r->default_datatype) {
8475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8479                 }
8480                 if (r->dependent_files) {
8481                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8482                 }
8483         }
8484         return NDR_ERR_SUCCESS;
8485 }
8486
8487 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8488 {
8489         uint32_t _ptr_driver_name;
8490         TALLOC_CTX *_mem_save_driver_name_0;
8491         uint32_t _ptr_architecture;
8492         TALLOC_CTX *_mem_save_architecture_0;
8493         uint32_t _ptr_driver_path;
8494         TALLOC_CTX *_mem_save_driver_path_0;
8495         uint32_t _ptr_data_file;
8496         TALLOC_CTX *_mem_save_data_file_0;
8497         uint32_t _ptr_config_file;
8498         TALLOC_CTX *_mem_save_config_file_0;
8499         uint32_t _ptr_help_file;
8500         TALLOC_CTX *_mem_save_help_file_0;
8501         uint32_t _ptr_monitor_name;
8502         TALLOC_CTX *_mem_save_monitor_name_0;
8503         uint32_t _ptr_default_datatype;
8504         TALLOC_CTX *_mem_save_default_datatype_0;
8505         uint32_t _ptr_dependent_files;
8506         TALLOC_CTX *_mem_save_dependent_files_0;
8507         if (ndr_flags & NDR_SCALARS) {
8508                 NDR_CHECK(ndr_pull_align(ndr, 5));
8509                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8511                 if (_ptr_driver_name) {
8512                         NDR_PULL_ALLOC(ndr, r->driver_name);
8513                 } else {
8514                         r->driver_name = NULL;
8515                 }
8516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8517                 if (_ptr_architecture) {
8518                         NDR_PULL_ALLOC(ndr, r->architecture);
8519                 } else {
8520                         r->architecture = NULL;
8521                 }
8522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8523                 if (_ptr_driver_path) {
8524                         NDR_PULL_ALLOC(ndr, r->driver_path);
8525                 } else {
8526                         r->driver_path = NULL;
8527                 }
8528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8529                 if (_ptr_data_file) {
8530                         NDR_PULL_ALLOC(ndr, r->data_file);
8531                 } else {
8532                         r->data_file = NULL;
8533                 }
8534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8535                 if (_ptr_config_file) {
8536                         NDR_PULL_ALLOC(ndr, r->config_file);
8537                 } else {
8538                         r->config_file = NULL;
8539                 }
8540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8541                 if (_ptr_help_file) {
8542                         NDR_PULL_ALLOC(ndr, r->help_file);
8543                 } else {
8544                         r->help_file = NULL;
8545                 }
8546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8547                 if (_ptr_monitor_name) {
8548                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8549                 } else {
8550                         r->monitor_name = NULL;
8551                 }
8552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8553                 if (_ptr_default_datatype) {
8554                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8555                 } else {
8556                         r->default_datatype = NULL;
8557                 }
8558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8560                 if (_ptr_dependent_files) {
8561                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8562                 } else {
8563                         r->dependent_files = NULL;
8564                 }
8565                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8566         }
8567         if (ndr_flags & NDR_BUFFERS) {
8568                 if (r->driver_name) {
8569                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8570                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8573                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8575                         }
8576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8579                 }
8580                 if (r->architecture) {
8581                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8582                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8585                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8586                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8587                         }
8588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8591                 }
8592                 if (r->driver_path) {
8593                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8594                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8597                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8598                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8599                         }
8600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8603                 }
8604                 if (r->data_file) {
8605                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8606                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8609                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8610                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8611                         }
8612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8615                 }
8616                 if (r->config_file) {
8617                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8618                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8621                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8622                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8623                         }
8624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8627                 }
8628                 if (r->help_file) {
8629                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8630                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8633                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8634                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8635                         }
8636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8639                 }
8640                 if (r->monitor_name) {
8641                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8642                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8645                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8646                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8647                         }
8648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8651                 }
8652                 if (r->default_datatype) {
8653                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8654                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8657                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8658                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8659                         }
8660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8663                 }
8664                 if (r->dependent_files) {
8665                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8666                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8667                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8669                 }
8670         }
8671         return NDR_ERR_SUCCESS;
8672 }
8673
8674 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8675 {
8676         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8677         ndr->depth++;
8678         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8679         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8680         ndr->depth++;
8681         if (r->driver_name) {
8682                 ndr_print_string(ndr, "driver_name", r->driver_name);
8683         }
8684         ndr->depth--;
8685         ndr_print_ptr(ndr, "architecture", r->architecture);
8686         ndr->depth++;
8687         if (r->architecture) {
8688                 ndr_print_string(ndr, "architecture", r->architecture);
8689         }
8690         ndr->depth--;
8691         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8692         ndr->depth++;
8693         if (r->driver_path) {
8694                 ndr_print_string(ndr, "driver_path", r->driver_path);
8695         }
8696         ndr->depth--;
8697         ndr_print_ptr(ndr, "data_file", r->data_file);
8698         ndr->depth++;
8699         if (r->data_file) {
8700                 ndr_print_string(ndr, "data_file", r->data_file);
8701         }
8702         ndr->depth--;
8703         ndr_print_ptr(ndr, "config_file", r->config_file);
8704         ndr->depth++;
8705         if (r->config_file) {
8706                 ndr_print_string(ndr, "config_file", r->config_file);
8707         }
8708         ndr->depth--;
8709         ndr_print_ptr(ndr, "help_file", r->help_file);
8710         ndr->depth++;
8711         if (r->help_file) {
8712                 ndr_print_string(ndr, "help_file", r->help_file);
8713         }
8714         ndr->depth--;
8715         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8716         ndr->depth++;
8717         if (r->monitor_name) {
8718                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8719         }
8720         ndr->depth--;
8721         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8722         ndr->depth++;
8723         if (r->default_datatype) {
8724                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8725         }
8726         ndr->depth--;
8727         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8728         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8729         ndr->depth++;
8730         if (r->dependent_files) {
8731                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8732         }
8733         ndr->depth--;
8734         ndr->depth--;
8735 }
8736
8737 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8738 {
8739         if (ndr_flags & NDR_SCALARS) {
8740                 NDR_CHECK(ndr_push_align(ndr, 5));
8741                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8746                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8754                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8755         }
8756         if (ndr_flags & NDR_BUFFERS) {
8757                 if (r->driver_name) {
8758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8762                 }
8763                 if (r->architecture) {
8764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8768                 }
8769                 if (r->driver_path) {
8770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8774                 }
8775                 if (r->data_file) {
8776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8780                 }
8781                 if (r->config_file) {
8782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8786                 }
8787                 if (r->help_file) {
8788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8792                 }
8793                 if (r->monitor_name) {
8794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8798                 }
8799                 if (r->default_datatype) {
8800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8804                 }
8805                 if (r->dependent_files) {
8806                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8807                 }
8808                 if (r->previous_names) {
8809                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8810                 }
8811         }
8812         return NDR_ERR_SUCCESS;
8813 }
8814
8815 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8816 {
8817         uint32_t _ptr_driver_name;
8818         TALLOC_CTX *_mem_save_driver_name_0;
8819         uint32_t _ptr_architecture;
8820         TALLOC_CTX *_mem_save_architecture_0;
8821         uint32_t _ptr_driver_path;
8822         TALLOC_CTX *_mem_save_driver_path_0;
8823         uint32_t _ptr_data_file;
8824         TALLOC_CTX *_mem_save_data_file_0;
8825         uint32_t _ptr_config_file;
8826         TALLOC_CTX *_mem_save_config_file_0;
8827         uint32_t _ptr_help_file;
8828         TALLOC_CTX *_mem_save_help_file_0;
8829         uint32_t _ptr_monitor_name;
8830         TALLOC_CTX *_mem_save_monitor_name_0;
8831         uint32_t _ptr_default_datatype;
8832         TALLOC_CTX *_mem_save_default_datatype_0;
8833         uint32_t _ptr_dependent_files;
8834         TALLOC_CTX *_mem_save_dependent_files_0;
8835         uint32_t _ptr_previous_names;
8836         TALLOC_CTX *_mem_save_previous_names_0;
8837         if (ndr_flags & NDR_SCALARS) {
8838                 NDR_CHECK(ndr_pull_align(ndr, 5));
8839                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8841                 if (_ptr_driver_name) {
8842                         NDR_PULL_ALLOC(ndr, r->driver_name);
8843                 } else {
8844                         r->driver_name = NULL;
8845                 }
8846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8847                 if (_ptr_architecture) {
8848                         NDR_PULL_ALLOC(ndr, r->architecture);
8849                 } else {
8850                         r->architecture = NULL;
8851                 }
8852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8853                 if (_ptr_driver_path) {
8854                         NDR_PULL_ALLOC(ndr, r->driver_path);
8855                 } else {
8856                         r->driver_path = NULL;
8857                 }
8858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8859                 if (_ptr_data_file) {
8860                         NDR_PULL_ALLOC(ndr, r->data_file);
8861                 } else {
8862                         r->data_file = NULL;
8863                 }
8864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8865                 if (_ptr_config_file) {
8866                         NDR_PULL_ALLOC(ndr, r->config_file);
8867                 } else {
8868                         r->config_file = NULL;
8869                 }
8870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8871                 if (_ptr_help_file) {
8872                         NDR_PULL_ALLOC(ndr, r->help_file);
8873                 } else {
8874                         r->help_file = NULL;
8875                 }
8876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8877                 if (_ptr_monitor_name) {
8878                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8879                 } else {
8880                         r->monitor_name = NULL;
8881                 }
8882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8883                 if (_ptr_default_datatype) {
8884                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8885                 } else {
8886                         r->default_datatype = NULL;
8887                 }
8888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8890                 if (_ptr_dependent_files) {
8891                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8892                 } else {
8893                         r->dependent_files = NULL;
8894                 }
8895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8897                 if (_ptr_previous_names) {
8898                         NDR_PULL_ALLOC(ndr, r->previous_names);
8899                 } else {
8900                         r->previous_names = NULL;
8901                 }
8902                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8903         }
8904         if (ndr_flags & NDR_BUFFERS) {
8905                 if (r->driver_name) {
8906                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8907                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8908                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8909                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8910                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8911                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8912                         }
8913                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8914                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8916                 }
8917                 if (r->architecture) {
8918                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8919                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8922                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8923                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8924                         }
8925                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8928                 }
8929                 if (r->driver_path) {
8930                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8931                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8934                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8935                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8936                         }
8937                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8938                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8940                 }
8941                 if (r->data_file) {
8942                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8943                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8944                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8945                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8946                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8947                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8948                         }
8949                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8950                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8951                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8952                 }
8953                 if (r->config_file) {
8954                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8955                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8956                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8957                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8958                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8959                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8960                         }
8961                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8962                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8964                 }
8965                 if (r->help_file) {
8966                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8967                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8970                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8972                         }
8973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8976                 }
8977                 if (r->monitor_name) {
8978                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8979                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8982                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8984                         }
8985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8988                 }
8989                 if (r->default_datatype) {
8990                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8991                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8994                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8995                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8996                         }
8997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9000                 }
9001                 if (r->dependent_files) {
9002                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9003                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9004                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9006                 }
9007                 if (r->previous_names) {
9008                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9009                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9010                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9012                 }
9013         }
9014         return NDR_ERR_SUCCESS;
9015 }
9016
9017 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9018 {
9019         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9020         ndr->depth++;
9021         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9022         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9023         ndr->depth++;
9024         if (r->driver_name) {
9025                 ndr_print_string(ndr, "driver_name", r->driver_name);
9026         }
9027         ndr->depth--;
9028         ndr_print_ptr(ndr, "architecture", r->architecture);
9029         ndr->depth++;
9030         if (r->architecture) {
9031                 ndr_print_string(ndr, "architecture", r->architecture);
9032         }
9033         ndr->depth--;
9034         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9035         ndr->depth++;
9036         if (r->driver_path) {
9037                 ndr_print_string(ndr, "driver_path", r->driver_path);
9038         }
9039         ndr->depth--;
9040         ndr_print_ptr(ndr, "data_file", r->data_file);
9041         ndr->depth++;
9042         if (r->data_file) {
9043                 ndr_print_string(ndr, "data_file", r->data_file);
9044         }
9045         ndr->depth--;
9046         ndr_print_ptr(ndr, "config_file", r->config_file);
9047         ndr->depth++;
9048         if (r->config_file) {
9049                 ndr_print_string(ndr, "config_file", r->config_file);
9050         }
9051         ndr->depth--;
9052         ndr_print_ptr(ndr, "help_file", r->help_file);
9053         ndr->depth++;
9054         if (r->help_file) {
9055                 ndr_print_string(ndr, "help_file", r->help_file);
9056         }
9057         ndr->depth--;
9058         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9059         ndr->depth++;
9060         if (r->monitor_name) {
9061                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9062         }
9063         ndr->depth--;
9064         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9065         ndr->depth++;
9066         if (r->default_datatype) {
9067                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9068         }
9069         ndr->depth--;
9070         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9071         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9072         ndr->depth++;
9073         if (r->dependent_files) {
9074                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9075         }
9076         ndr->depth--;
9077         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9078         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9079         ndr->depth++;
9080         if (r->previous_names) {
9081                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9082         }
9083         ndr->depth--;
9084         ndr->depth--;
9085 }
9086
9087 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9088 {
9089         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9090         return NDR_ERR_SUCCESS;
9091 }
9092
9093 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9094 {
9095         uint32_t v;
9096         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9097         *r = v;
9098         return NDR_ERR_SUCCESS;
9099 }
9100
9101 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9102 {
9103         ndr_print_uint32(ndr, name, r);
9104         ndr->depth++;
9105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9106         ndr->depth--;
9107 }
9108
9109 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9110 {
9111         if (ndr_flags & NDR_SCALARS) {
9112                 NDR_CHECK(ndr_push_align(ndr, 8));
9113                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9126                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9127                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9132                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9133         }
9134         if (ndr_flags & NDR_BUFFERS) {
9135                 if (r->driver_name) {
9136                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9139                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9140                 }
9141                 if (r->architecture) {
9142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9145                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9146                 }
9147                 if (r->driver_path) {
9148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9149                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9151                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9152                 }
9153                 if (r->data_file) {
9154                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9158                 }
9159                 if (r->config_file) {
9160                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9161                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9163                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9164                 }
9165                 if (r->help_file) {
9166                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9170                 }
9171                 if (r->monitor_name) {
9172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9173                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9175                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9176                 }
9177                 if (r->default_datatype) {
9178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9179                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9181                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9182                 }
9183                 if (r->dependent_files) {
9184                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9185                 }
9186                 if (r->previous_names) {
9187                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9188                 }
9189                 if (r->manufacturer_name) {
9190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9193                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9194                 }
9195                 if (r->manufacturer_url) {
9196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9200                 }
9201                 if (r->hardware_id) {
9202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9205                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9206                 }
9207                 if (r->provider) {
9208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9212                 }
9213         }
9214         return NDR_ERR_SUCCESS;
9215 }
9216
9217 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9218 {
9219         uint32_t _ptr_driver_name;
9220         TALLOC_CTX *_mem_save_driver_name_0;
9221         uint32_t _ptr_architecture;
9222         TALLOC_CTX *_mem_save_architecture_0;
9223         uint32_t _ptr_driver_path;
9224         TALLOC_CTX *_mem_save_driver_path_0;
9225         uint32_t _ptr_data_file;
9226         TALLOC_CTX *_mem_save_data_file_0;
9227         uint32_t _ptr_config_file;
9228         TALLOC_CTX *_mem_save_config_file_0;
9229         uint32_t _ptr_help_file;
9230         TALLOC_CTX *_mem_save_help_file_0;
9231         uint32_t _ptr_monitor_name;
9232         TALLOC_CTX *_mem_save_monitor_name_0;
9233         uint32_t _ptr_default_datatype;
9234         TALLOC_CTX *_mem_save_default_datatype_0;
9235         uint32_t _ptr_dependent_files;
9236         TALLOC_CTX *_mem_save_dependent_files_0;
9237         uint32_t _ptr_previous_names;
9238         TALLOC_CTX *_mem_save_previous_names_0;
9239         uint32_t _ptr_manufacturer_name;
9240         TALLOC_CTX *_mem_save_manufacturer_name_0;
9241         uint32_t _ptr_manufacturer_url;
9242         TALLOC_CTX *_mem_save_manufacturer_url_0;
9243         uint32_t _ptr_hardware_id;
9244         TALLOC_CTX *_mem_save_hardware_id_0;
9245         uint32_t _ptr_provider;
9246         TALLOC_CTX *_mem_save_provider_0;
9247         if (ndr_flags & NDR_SCALARS) {
9248                 NDR_CHECK(ndr_pull_align(ndr, 8));
9249                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9251                 if (_ptr_driver_name) {
9252                         NDR_PULL_ALLOC(ndr, r->driver_name);
9253                 } else {
9254                         r->driver_name = NULL;
9255                 }
9256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9257                 if (_ptr_architecture) {
9258                         NDR_PULL_ALLOC(ndr, r->architecture);
9259                 } else {
9260                         r->architecture = NULL;
9261                 }
9262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9263                 if (_ptr_driver_path) {
9264                         NDR_PULL_ALLOC(ndr, r->driver_path);
9265                 } else {
9266                         r->driver_path = NULL;
9267                 }
9268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9269                 if (_ptr_data_file) {
9270                         NDR_PULL_ALLOC(ndr, r->data_file);
9271                 } else {
9272                         r->data_file = NULL;
9273                 }
9274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9275                 if (_ptr_config_file) {
9276                         NDR_PULL_ALLOC(ndr, r->config_file);
9277                 } else {
9278                         r->config_file = NULL;
9279                 }
9280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9281                 if (_ptr_help_file) {
9282                         NDR_PULL_ALLOC(ndr, r->help_file);
9283                 } else {
9284                         r->help_file = NULL;
9285                 }
9286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9287                 if (_ptr_monitor_name) {
9288                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9289                 } else {
9290                         r->monitor_name = NULL;
9291                 }
9292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9293                 if (_ptr_default_datatype) {
9294                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9295                 } else {
9296                         r->default_datatype = NULL;
9297                 }
9298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9300                 if (_ptr_dependent_files) {
9301                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9302                 } else {
9303                         r->dependent_files = NULL;
9304                 }
9305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9307                 if (_ptr_previous_names) {
9308                         NDR_PULL_ALLOC(ndr, r->previous_names);
9309                 } else {
9310                         r->previous_names = NULL;
9311                 }
9312                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9313                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9315                 if (_ptr_manufacturer_name) {
9316                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9317                 } else {
9318                         r->manufacturer_name = NULL;
9319                 }
9320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9321                 if (_ptr_manufacturer_url) {
9322                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9323                 } else {
9324                         r->manufacturer_url = NULL;
9325                 }
9326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9327                 if (_ptr_hardware_id) {
9328                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9329                 } else {
9330                         r->hardware_id = NULL;
9331                 }
9332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9333                 if (_ptr_provider) {
9334                         NDR_PULL_ALLOC(ndr, r->provider);
9335                 } else {
9336                         r->provider = NULL;
9337                 }
9338                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9339         }
9340         if (ndr_flags & NDR_BUFFERS) {
9341                 if (r->driver_name) {
9342                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9343                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9344                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9345                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9346                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9347                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9348                         }
9349                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9350                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9352                 }
9353                 if (r->architecture) {
9354                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9355                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9358                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9359                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9360                         }
9361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9364                 }
9365                 if (r->driver_path) {
9366                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9367                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9369                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9370                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9371                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9372                         }
9373                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9374                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9375                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9376                 }
9377                 if (r->data_file) {
9378                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9379                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9380                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9381                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9382                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9383                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9384                         }
9385                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9386                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9388                 }
9389                 if (r->config_file) {
9390                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9391                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9392                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9393                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9394                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9395                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9396                         }
9397                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9398                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9400                 }
9401                 if (r->help_file) {
9402                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9403                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9404                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9405                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9406                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9407                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9408                         }
9409                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9410                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9412                 }
9413                 if (r->monitor_name) {
9414                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9415                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9416                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9417                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9418                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9419                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9420                         }
9421                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9422                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9424                 }
9425                 if (r->default_datatype) {
9426                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9427                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9429                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9430                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9431                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9432                         }
9433                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9434                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9436                 }
9437                 if (r->dependent_files) {
9438                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9439                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9440                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9442                 }
9443                 if (r->previous_names) {
9444                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9445                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9446                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9448                 }
9449                 if (r->manufacturer_name) {
9450                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9451                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9452                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9453                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9454                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9455                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9456                         }
9457                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9458                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9460                 }
9461                 if (r->manufacturer_url) {
9462                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9463                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9464                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9465                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9466                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9467                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9468                         }
9469                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9470                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9471                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9472                 }
9473                 if (r->hardware_id) {
9474                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9475                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9476                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9477                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9478                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9479                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9480                         }
9481                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9482                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9484                 }
9485                 if (r->provider) {
9486                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9487                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9490                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9491                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9492                         }
9493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9496                 }
9497         }
9498         return NDR_ERR_SUCCESS;
9499 }
9500
9501 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9502 {
9503         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9504         ndr->depth++;
9505         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9506         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9507         ndr->depth++;
9508         if (r->driver_name) {
9509                 ndr_print_string(ndr, "driver_name", r->driver_name);
9510         }
9511         ndr->depth--;
9512         ndr_print_ptr(ndr, "architecture", r->architecture);
9513         ndr->depth++;
9514         if (r->architecture) {
9515                 ndr_print_string(ndr, "architecture", r->architecture);
9516         }
9517         ndr->depth--;
9518         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9519         ndr->depth++;
9520         if (r->driver_path) {
9521                 ndr_print_string(ndr, "driver_path", r->driver_path);
9522         }
9523         ndr->depth--;
9524         ndr_print_ptr(ndr, "data_file", r->data_file);
9525         ndr->depth++;
9526         if (r->data_file) {
9527                 ndr_print_string(ndr, "data_file", r->data_file);
9528         }
9529         ndr->depth--;
9530         ndr_print_ptr(ndr, "config_file", r->config_file);
9531         ndr->depth++;
9532         if (r->config_file) {
9533                 ndr_print_string(ndr, "config_file", r->config_file);
9534         }
9535         ndr->depth--;
9536         ndr_print_ptr(ndr, "help_file", r->help_file);
9537         ndr->depth++;
9538         if (r->help_file) {
9539                 ndr_print_string(ndr, "help_file", r->help_file);
9540         }
9541         ndr->depth--;
9542         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9543         ndr->depth++;
9544         if (r->monitor_name) {
9545                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9546         }
9547         ndr->depth--;
9548         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9549         ndr->depth++;
9550         if (r->default_datatype) {
9551                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9552         }
9553         ndr->depth--;
9554         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9555         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9556         ndr->depth++;
9557         if (r->dependent_files) {
9558                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9559         }
9560         ndr->depth--;
9561         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9562         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9563         ndr->depth++;
9564         if (r->previous_names) {
9565                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9566         }
9567         ndr->depth--;
9568         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9569         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9570         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9571         ndr->depth++;
9572         if (r->manufacturer_name) {
9573                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9574         }
9575         ndr->depth--;
9576         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9577         ndr->depth++;
9578         if (r->manufacturer_url) {
9579                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9580         }
9581         ndr->depth--;
9582         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9583         ndr->depth++;
9584         if (r->hardware_id) {
9585                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9586         }
9587         ndr->depth--;
9588         ndr_print_ptr(ndr, "provider", r->provider);
9589         ndr->depth++;
9590         if (r->provider) {
9591                 ndr_print_string(ndr, "provider", r->provider);
9592         }
9593         ndr->depth--;
9594         ndr->depth--;
9595 }
9596
9597 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9598 {
9599         if (ndr_flags & NDR_SCALARS) {
9600                 NDR_CHECK(ndr_push_align(ndr, 8));
9601                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9614                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9615                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9628                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9629                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9630                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9631         }
9632         if (ndr_flags & NDR_BUFFERS) {
9633                 if (r->driver_name) {
9634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9637                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9638                 }
9639                 if (r->architecture) {
9640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9644                 }
9645                 if (r->driver_path) {
9646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9650                 }
9651                 if (r->data_file) {
9652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9656                 }
9657                 if (r->config_file) {
9658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9661                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9662                 }
9663                 if (r->help_file) {
9664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9667                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9668                 }
9669                 if (r->monitor_name) {
9670                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9671                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9672                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9673                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9674                 }
9675                 if (r->default_datatype) {
9676                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9677                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9679                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9680                 }
9681                 if (r->dependent_files) {
9682                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9683                 }
9684                 if (r->previous_names) {
9685                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9686                 }
9687                 if (r->manufacturer_name) {
9688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9692                 }
9693                 if (r->manufacturer_url) {
9694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9698                 }
9699                 if (r->hardware_id) {
9700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9702                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9703                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9704                 }
9705                 if (r->provider) {
9706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9710                 }
9711                 if (r->print_processor) {
9712                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9713                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9716                 }
9717                 if (r->vendor_setup) {
9718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9721                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9722                 }
9723                 if (r->color_profiles) {
9724                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9725                 }
9726                 if (r->inf_path) {
9727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9731                 }
9732                 if (r->core_driver_dependencies) {
9733                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9734                 }
9735         }
9736         return NDR_ERR_SUCCESS;
9737 }
9738
9739 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9740 {
9741         uint32_t _ptr_driver_name;
9742         TALLOC_CTX *_mem_save_driver_name_0;
9743         uint32_t _ptr_architecture;
9744         TALLOC_CTX *_mem_save_architecture_0;
9745         uint32_t _ptr_driver_path;
9746         TALLOC_CTX *_mem_save_driver_path_0;
9747         uint32_t _ptr_data_file;
9748         TALLOC_CTX *_mem_save_data_file_0;
9749         uint32_t _ptr_config_file;
9750         TALLOC_CTX *_mem_save_config_file_0;
9751         uint32_t _ptr_help_file;
9752         TALLOC_CTX *_mem_save_help_file_0;
9753         uint32_t _ptr_monitor_name;
9754         TALLOC_CTX *_mem_save_monitor_name_0;
9755         uint32_t _ptr_default_datatype;
9756         TALLOC_CTX *_mem_save_default_datatype_0;
9757         uint32_t _ptr_dependent_files;
9758         TALLOC_CTX *_mem_save_dependent_files_0;
9759         uint32_t _ptr_previous_names;
9760         TALLOC_CTX *_mem_save_previous_names_0;
9761         uint32_t _ptr_manufacturer_name;
9762         TALLOC_CTX *_mem_save_manufacturer_name_0;
9763         uint32_t _ptr_manufacturer_url;
9764         TALLOC_CTX *_mem_save_manufacturer_url_0;
9765         uint32_t _ptr_hardware_id;
9766         TALLOC_CTX *_mem_save_hardware_id_0;
9767         uint32_t _ptr_provider;
9768         TALLOC_CTX *_mem_save_provider_0;
9769         uint32_t _ptr_print_processor;
9770         TALLOC_CTX *_mem_save_print_processor_0;
9771         uint32_t _ptr_vendor_setup;
9772         TALLOC_CTX *_mem_save_vendor_setup_0;
9773         uint32_t _ptr_color_profiles;
9774         TALLOC_CTX *_mem_save_color_profiles_0;
9775         uint32_t _ptr_inf_path;
9776         TALLOC_CTX *_mem_save_inf_path_0;
9777         uint32_t _ptr_core_driver_dependencies;
9778         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9779         if (ndr_flags & NDR_SCALARS) {
9780                 NDR_CHECK(ndr_pull_align(ndr, 8));
9781                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9783                 if (_ptr_driver_name) {
9784                         NDR_PULL_ALLOC(ndr, r->driver_name);
9785                 } else {
9786                         r->driver_name = NULL;
9787                 }
9788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9789                 if (_ptr_architecture) {
9790                         NDR_PULL_ALLOC(ndr, r->architecture);
9791                 } else {
9792                         r->architecture = NULL;
9793                 }
9794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9795                 if (_ptr_driver_path) {
9796                         NDR_PULL_ALLOC(ndr, r->driver_path);
9797                 } else {
9798                         r->driver_path = NULL;
9799                 }
9800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9801                 if (_ptr_data_file) {
9802                         NDR_PULL_ALLOC(ndr, r->data_file);
9803                 } else {
9804                         r->data_file = NULL;
9805                 }
9806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9807                 if (_ptr_config_file) {
9808                         NDR_PULL_ALLOC(ndr, r->config_file);
9809                 } else {
9810                         r->config_file = NULL;
9811                 }
9812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9813                 if (_ptr_help_file) {
9814                         NDR_PULL_ALLOC(ndr, r->help_file);
9815                 } else {
9816                         r->help_file = NULL;
9817                 }
9818                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9819                 if (_ptr_monitor_name) {
9820                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9821                 } else {
9822                         r->monitor_name = NULL;
9823                 }
9824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9825                 if (_ptr_default_datatype) {
9826                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9827                 } else {
9828                         r->default_datatype = NULL;
9829                 }
9830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9832                 if (_ptr_dependent_files) {
9833                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9834                 } else {
9835                         r->dependent_files = NULL;
9836                 }
9837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9839                 if (_ptr_previous_names) {
9840                         NDR_PULL_ALLOC(ndr, r->previous_names);
9841                 } else {
9842                         r->previous_names = NULL;
9843                 }
9844                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9845                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9847                 if (_ptr_manufacturer_name) {
9848                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9849                 } else {
9850                         r->manufacturer_name = NULL;
9851                 }
9852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9853                 if (_ptr_manufacturer_url) {
9854                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9855                 } else {
9856                         r->manufacturer_url = NULL;
9857                 }
9858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9859                 if (_ptr_hardware_id) {
9860                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9861                 } else {
9862                         r->hardware_id = NULL;
9863                 }
9864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9865                 if (_ptr_provider) {
9866                         NDR_PULL_ALLOC(ndr, r->provider);
9867                 } else {
9868                         r->provider = NULL;
9869                 }
9870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9871                 if (_ptr_print_processor) {
9872                         NDR_PULL_ALLOC(ndr, r->print_processor);
9873                 } else {
9874                         r->print_processor = NULL;
9875                 }
9876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9877                 if (_ptr_vendor_setup) {
9878                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9879                 } else {
9880                         r->vendor_setup = NULL;
9881                 }
9882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9884                 if (_ptr_color_profiles) {
9885                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9886                 } else {
9887                         r->color_profiles = NULL;
9888                 }
9889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9890                 if (_ptr_inf_path) {
9891                         NDR_PULL_ALLOC(ndr, r->inf_path);
9892                 } else {
9893                         r->inf_path = NULL;
9894                 }
9895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9898                 if (_ptr_core_driver_dependencies) {
9899                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9900                 } else {
9901                         r->core_driver_dependencies = NULL;
9902                 }
9903                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9904                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9905                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9906         }
9907         if (ndr_flags & NDR_BUFFERS) {
9908                 if (r->driver_name) {
9909                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9910                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9913                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9914                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9915                         }
9916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9919                 }
9920                 if (r->architecture) {
9921                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9922                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9925                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9926                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9927                         }
9928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9929                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9931                 }
9932                 if (r->driver_path) {
9933                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9934                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9937                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9938                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9939                         }
9940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9943                 }
9944                 if (r->data_file) {
9945                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9946                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9947                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9948                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9949                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9950                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9951                         }
9952                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9953                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9955                 }
9956                 if (r->config_file) {
9957                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9958                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9961                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9962                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9963                         }
9964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9967                 }
9968                 if (r->help_file) {
9969                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9970                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9973                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9974                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9975                         }
9976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9979                 }
9980                 if (r->monitor_name) {
9981                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9982                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9985                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9986                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9987                         }
9988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9991                 }
9992                 if (r->default_datatype) {
9993                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9994                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9997                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9998                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9999                         }
10000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10001                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10003                 }
10004                 if (r->dependent_files) {
10005                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10006                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10007                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10009                 }
10010                 if (r->previous_names) {
10011                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10012                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10013                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10015                 }
10016                 if (r->manufacturer_name) {
10017                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10018                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10021                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10022                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
10023                         }
10024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10027                 }
10028                 if (r->manufacturer_url) {
10029                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10030                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10033                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10034                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
10035                         }
10036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10039                 }
10040                 if (r->hardware_id) {
10041                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10042                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10045                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10046                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
10047                         }
10048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10049                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10051                 }
10052                 if (r->provider) {
10053                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10054                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10057                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10058                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
10059                         }
10060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10063                 }
10064                 if (r->print_processor) {
10065                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10066                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10069                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10070                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
10071                         }
10072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10075                 }
10076                 if (r->vendor_setup) {
10077                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10078                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10081                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10082                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
10083                         }
10084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10087                 }
10088                 if (r->color_profiles) {
10089                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10090                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10091                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10093                 }
10094                 if (r->inf_path) {
10095                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10096                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10099                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10100                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
10101                         }
10102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10105                 }
10106                 if (r->core_driver_dependencies) {
10107                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10108                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10109                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10111                 }
10112         }
10113         return NDR_ERR_SUCCESS;
10114 }
10115
10116 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10117 {
10118         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10119         ndr->depth++;
10120         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10121         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10122         ndr->depth++;
10123         if (r->driver_name) {
10124                 ndr_print_string(ndr, "driver_name", r->driver_name);
10125         }
10126         ndr->depth--;
10127         ndr_print_ptr(ndr, "architecture", r->architecture);
10128         ndr->depth++;
10129         if (r->architecture) {
10130                 ndr_print_string(ndr, "architecture", r->architecture);
10131         }
10132         ndr->depth--;
10133         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10134         ndr->depth++;
10135         if (r->driver_path) {
10136                 ndr_print_string(ndr, "driver_path", r->driver_path);
10137         }
10138         ndr->depth--;
10139         ndr_print_ptr(ndr, "data_file", r->data_file);
10140         ndr->depth++;
10141         if (r->data_file) {
10142                 ndr_print_string(ndr, "data_file", r->data_file);
10143         }
10144         ndr->depth--;
10145         ndr_print_ptr(ndr, "config_file", r->config_file);
10146         ndr->depth++;
10147         if (r->config_file) {
10148                 ndr_print_string(ndr, "config_file", r->config_file);
10149         }
10150         ndr->depth--;
10151         ndr_print_ptr(ndr, "help_file", r->help_file);
10152         ndr->depth++;
10153         if (r->help_file) {
10154                 ndr_print_string(ndr, "help_file", r->help_file);
10155         }
10156         ndr->depth--;
10157         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10158         ndr->depth++;
10159         if (r->monitor_name) {
10160                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10161         }
10162         ndr->depth--;
10163         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10164         ndr->depth++;
10165         if (r->default_datatype) {
10166                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10167         }
10168         ndr->depth--;
10169         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
10170         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10171         ndr->depth++;
10172         if (r->dependent_files) {
10173                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10174         }
10175         ndr->depth--;
10176         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
10177         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10178         ndr->depth++;
10179         if (r->previous_names) {
10180                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10181         }
10182         ndr->depth--;
10183         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10184         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10185         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10186         ndr->depth++;
10187         if (r->manufacturer_name) {
10188                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10189         }
10190         ndr->depth--;
10191         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10192         ndr->depth++;
10193         if (r->manufacturer_url) {
10194                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10195         }
10196         ndr->depth--;
10197         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10198         ndr->depth++;
10199         if (r->hardware_id) {
10200                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10201         }
10202         ndr->depth--;
10203         ndr_print_ptr(ndr, "provider", r->provider);
10204         ndr->depth++;
10205         if (r->provider) {
10206                 ndr_print_string(ndr, "provider", r->provider);
10207         }
10208         ndr->depth--;
10209         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10210         ndr->depth++;
10211         if (r->print_processor) {
10212                 ndr_print_string(ndr, "print_processor", r->print_processor);
10213         }
10214         ndr->depth--;
10215         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10216         ndr->depth++;
10217         if (r->vendor_setup) {
10218                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10219         }
10220         ndr->depth--;
10221         ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
10222         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10223         ndr->depth++;
10224         if (r->color_profiles) {
10225                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10226         }
10227         ndr->depth--;
10228         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10229         ndr->depth++;
10230         if (r->inf_path) {
10231                 ndr_print_string(ndr, "inf_path", r->inf_path);
10232         }
10233         ndr->depth--;
10234         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10235         ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
10236         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10237         ndr->depth++;
10238         if (r->core_driver_dependencies) {
10239                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10240         }
10241         ndr->depth--;
10242         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10243         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10244         ndr->depth--;
10245 }
10246
10247 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10248 {
10249         if (ndr_flags & NDR_SCALARS) {
10250                 int level = ndr_push_get_switch_value(ndr, r);
10251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10252                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10253                 switch (level) {
10254                         case 1: {
10255                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10256                         break; }
10257
10258                         case 2: {
10259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10260                         break; }
10261
10262                         case 3: {
10263                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10264                         break; }
10265
10266                         case 4: {
10267                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10268                         break; }
10269
10270                         case 6: {
10271                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10272                         break; }
10273
10274                         case 8: {
10275                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10276                         break; }
10277
10278                         default:
10279                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10280                 }
10281         }
10282         if (ndr_flags & NDR_BUFFERS) {
10283                 int level = ndr_push_get_switch_value(ndr, r);
10284                 switch (level) {
10285                         case 1:
10286                                 if (r->info1) {
10287                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10288                                 }
10289                         break;
10290
10291                         case 2:
10292                                 if (r->info2) {
10293                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10294                                 }
10295                         break;
10296
10297                         case 3:
10298                                 if (r->info3) {
10299                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10300                                 }
10301                         break;
10302
10303                         case 4:
10304                                 if (r->info4) {
10305                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10306                                 }
10307                         break;
10308
10309                         case 6:
10310                                 if (r->info6) {
10311                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10312                                 }
10313                         break;
10314
10315                         case 8:
10316                                 if (r->info8) {
10317                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10318                                 }
10319                         break;
10320
10321                         default:
10322                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10323                 }
10324         }
10325         return NDR_ERR_SUCCESS;
10326 }
10327
10328 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10329 {
10330         int level;
10331         uint32_t _level;
10332         TALLOC_CTX *_mem_save_info1_0;
10333         TALLOC_CTX *_mem_save_info2_0;
10334         TALLOC_CTX *_mem_save_info3_0;
10335         TALLOC_CTX *_mem_save_info4_0;
10336         TALLOC_CTX *_mem_save_info6_0;
10337         TALLOC_CTX *_mem_save_info8_0;
10338         level = ndr_pull_get_switch_value(ndr, r);
10339         if (ndr_flags & NDR_SCALARS) {
10340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10341                 if (_level != level) {
10342                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10343                 }
10344                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10345                 switch (level) {
10346                         case 1: {
10347                                 uint32_t _ptr_info1;
10348                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10349                                 if (_ptr_info1) {
10350                                         NDR_PULL_ALLOC(ndr, r->info1);
10351                                 } else {
10352                                         r->info1 = NULL;
10353                                 }
10354                         break; }
10355
10356                         case 2: {
10357                                 uint32_t _ptr_info2;
10358                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10359                                 if (_ptr_info2) {
10360                                         NDR_PULL_ALLOC(ndr, r->info2);
10361                                 } else {
10362                                         r->info2 = NULL;
10363                                 }
10364                         break; }
10365
10366                         case 3: {
10367                                 uint32_t _ptr_info3;
10368                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10369                                 if (_ptr_info3) {
10370                                         NDR_PULL_ALLOC(ndr, r->info3);
10371                                 } else {
10372                                         r->info3 = NULL;
10373                                 }
10374                         break; }
10375
10376                         case 4: {
10377                                 uint32_t _ptr_info4;
10378                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10379                                 if (_ptr_info4) {
10380                                         NDR_PULL_ALLOC(ndr, r->info4);
10381                                 } else {
10382                                         r->info4 = NULL;
10383                                 }
10384                         break; }
10385
10386                         case 6: {
10387                                 uint32_t _ptr_info6;
10388                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10389                                 if (_ptr_info6) {
10390                                         NDR_PULL_ALLOC(ndr, r->info6);
10391                                 } else {
10392                                         r->info6 = NULL;
10393                                 }
10394                         break; }
10395
10396                         case 8: {
10397                                 uint32_t _ptr_info8;
10398                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10399                                 if (_ptr_info8) {
10400                                         NDR_PULL_ALLOC(ndr, r->info8);
10401                                 } else {
10402                                         r->info8 = NULL;
10403                                 }
10404                         break; }
10405
10406                         default:
10407                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10408                 }
10409         }
10410         if (ndr_flags & NDR_BUFFERS) {
10411                 switch (level) {
10412                         case 1:
10413                                 if (r->info1) {
10414                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10415                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10416                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10417                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10418                                 }
10419                         break;
10420
10421                         case 2:
10422                                 if (r->info2) {
10423                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10424                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10425                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10426                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10427                                 }
10428                         break;
10429
10430                         case 3:
10431                                 if (r->info3) {
10432                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10433                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10434                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10435                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10436                                 }
10437                         break;
10438
10439                         case 4:
10440                                 if (r->info4) {
10441                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10442                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10443                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10444                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10445                                 }
10446                         break;
10447
10448                         case 6:
10449                                 if (r->info6) {
10450                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10451                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10452                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10453                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10454                                 }
10455                         break;
10456
10457                         case 8:
10458                                 if (r->info8) {
10459                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10460                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10461                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10462                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10463                                 }
10464                         break;
10465
10466                         default:
10467                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10468                 }
10469         }
10470         return NDR_ERR_SUCCESS;
10471 }
10472
10473 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10474 {
10475         int level;
10476         level = ndr_print_get_switch_value(ndr, r);
10477         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10478         switch (level) {
10479                 case 1:
10480                         ndr_print_ptr(ndr, "info1", r->info1);
10481                         ndr->depth++;
10482                         if (r->info1) {
10483                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10484                         }
10485                         ndr->depth--;
10486                 break;
10487
10488                 case 2:
10489                         ndr_print_ptr(ndr, "info2", r->info2);
10490                         ndr->depth++;
10491                         if (r->info2) {
10492                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10493                         }
10494                         ndr->depth--;
10495                 break;
10496
10497                 case 3:
10498                         ndr_print_ptr(ndr, "info3", r->info3);
10499                         ndr->depth++;
10500                         if (r->info3) {
10501                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10502                         }
10503                         ndr->depth--;
10504                 break;
10505
10506                 case 4:
10507                         ndr_print_ptr(ndr, "info4", r->info4);
10508                         ndr->depth++;
10509                         if (r->info4) {
10510                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10511                         }
10512                         ndr->depth--;
10513                 break;
10514
10515                 case 6:
10516                         ndr_print_ptr(ndr, "info6", r->info6);
10517                         ndr->depth++;
10518                         if (r->info6) {
10519                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10520                         }
10521                         ndr->depth--;
10522                 break;
10523
10524                 case 8:
10525                         ndr_print_ptr(ndr, "info8", r->info8);
10526                         ndr->depth++;
10527                         if (r->info8) {
10528                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10529                         }
10530                         ndr->depth--;
10531                 break;
10532
10533                 default:
10534                         ndr_print_bad_level(ndr, name, level);
10535         }
10536 }
10537
10538 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10539 {
10540         if (ndr_flags & NDR_SCALARS) {
10541                 NDR_CHECK(ndr_push_align(ndr, 5));
10542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10543                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10544                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10545                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10546         }
10547         if (ndr_flags & NDR_BUFFERS) {
10548                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10549         }
10550         return NDR_ERR_SUCCESS;
10551 }
10552
10553 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10554 {
10555         if (ndr_flags & NDR_SCALARS) {
10556                 NDR_CHECK(ndr_pull_align(ndr, 5));
10557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10558                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10559                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10560                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10561         }
10562         if (ndr_flags & NDR_BUFFERS) {
10563                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10564         }
10565         return NDR_ERR_SUCCESS;
10566 }
10567
10568 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10569 {
10570         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10571         ndr->depth++;
10572         ndr_print_uint32(ndr, "level", r->level);
10573         ndr_print_set_switch_value(ndr, &r->info, r->level);
10574         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10575         ndr->depth--;
10576 }
10577
10578 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10579 {
10580         if (ndr_flags & NDR_SCALARS) {
10581                 NDR_CHECK(ndr_push_align(ndr, 5));
10582                 {
10583                         uint32_t _flags_save_string = ndr->flags;
10584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10586                         ndr->flags = _flags_save_string;
10587                 }
10588                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10589         }
10590         if (ndr_flags & NDR_BUFFERS) {
10591                 {
10592                         uint32_t _flags_save_string = ndr->flags;
10593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10594                         if (r->driver_name) {
10595                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10596                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10597                         }
10598                         ndr->flags = _flags_save_string;
10599                 }
10600         }
10601         return NDR_ERR_SUCCESS;
10602 }
10603
10604 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10605 {
10606         uint32_t _ptr_driver_name;
10607         TALLOC_CTX *_mem_save_driver_name_0;
10608         if (ndr_flags & NDR_SCALARS) {
10609                 NDR_CHECK(ndr_pull_align(ndr, 5));
10610                 {
10611                         uint32_t _flags_save_string = ndr->flags;
10612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10613                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10614                         if (_ptr_driver_name) {
10615                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10616                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10617                         } else {
10618                                 r->driver_name = NULL;
10619                         }
10620                         ndr->flags = _flags_save_string;
10621                 }
10622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10623         }
10624         if (ndr_flags & NDR_BUFFERS) {
10625                 {
10626                         uint32_t _flags_save_string = ndr->flags;
10627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10628                         if (r->driver_name) {
10629                                 uint32_t _relative_save_offset;
10630                                 _relative_save_offset = ndr->offset;
10631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10632                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10633                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10636                                 if (ndr->offset > ndr->relative_highest_offset) {
10637                                         ndr->relative_highest_offset = ndr->offset;
10638                                 }
10639                                 ndr->offset = _relative_save_offset;
10640                         }
10641                         ndr->flags = _flags_save_string;
10642                 }
10643         }
10644         return NDR_ERR_SUCCESS;
10645 }
10646
10647 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10648 {
10649         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10650         ndr->depth++;
10651         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10652         ndr->depth++;
10653         if (r->driver_name) {
10654                 ndr_print_string(ndr, "driver_name", r->driver_name);
10655         }
10656         ndr->depth--;
10657         ndr->depth--;
10658 }
10659
10660 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10661 {
10662         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10663 }
10664
10665 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10666 {
10667         if (ndr_flags & NDR_SCALARS) {
10668                 NDR_CHECK(ndr_push_align(ndr, 5));
10669                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10670                 {
10671                         uint32_t _flags_save_string = ndr->flags;
10672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10673                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10674                         ndr->flags = _flags_save_string;
10675                 }
10676                 {
10677                         uint32_t _flags_save_string = ndr->flags;
10678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10679                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10680                         ndr->flags = _flags_save_string;
10681                 }
10682                 {
10683                         uint32_t _flags_save_string = ndr->flags;
10684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10685                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10686                         ndr->flags = _flags_save_string;
10687                 }
10688                 {
10689                         uint32_t _flags_save_string = ndr->flags;
10690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10691                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10692                         ndr->flags = _flags_save_string;
10693                 }
10694                 {
10695                         uint32_t _flags_save_string = ndr->flags;
10696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10697                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10698                         ndr->flags = _flags_save_string;
10699                 }
10700                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10701         }
10702         if (ndr_flags & NDR_BUFFERS) {
10703                 {
10704                         uint32_t _flags_save_string = ndr->flags;
10705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10706                         if (r->driver_name) {
10707                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10708                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10709                         }
10710                         ndr->flags = _flags_save_string;
10711                 }
10712                 {
10713                         uint32_t _flags_save_string = ndr->flags;
10714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10715                         if (r->architecture) {
10716                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10717                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10718                         }
10719                         ndr->flags = _flags_save_string;
10720                 }
10721                 {
10722                         uint32_t _flags_save_string = ndr->flags;
10723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10724                         if (r->driver_path) {
10725                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10726                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10727                         }
10728                         ndr->flags = _flags_save_string;
10729                 }
10730                 {
10731                         uint32_t _flags_save_string = ndr->flags;
10732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10733                         if (r->data_file) {
10734                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10735                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10736                         }
10737                         ndr->flags = _flags_save_string;
10738                 }
10739                 {
10740                         uint32_t _flags_save_string = ndr->flags;
10741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10742                         if (r->config_file) {
10743                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10744                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10745                         }
10746                         ndr->flags = _flags_save_string;
10747                 }
10748         }
10749         return NDR_ERR_SUCCESS;
10750 }
10751
10752 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10753 {
10754         uint32_t _ptr_driver_name;
10755         TALLOC_CTX *_mem_save_driver_name_0;
10756         uint32_t _ptr_architecture;
10757         TALLOC_CTX *_mem_save_architecture_0;
10758         uint32_t _ptr_driver_path;
10759         TALLOC_CTX *_mem_save_driver_path_0;
10760         uint32_t _ptr_data_file;
10761         TALLOC_CTX *_mem_save_data_file_0;
10762         uint32_t _ptr_config_file;
10763         TALLOC_CTX *_mem_save_config_file_0;
10764         if (ndr_flags & NDR_SCALARS) {
10765                 NDR_CHECK(ndr_pull_align(ndr, 5));
10766                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10767                 {
10768                         uint32_t _flags_save_string = ndr->flags;
10769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10770                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10771                         if (_ptr_driver_name) {
10772                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10773                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10774                         } else {
10775                                 r->driver_name = NULL;
10776                         }
10777                         ndr->flags = _flags_save_string;
10778                 }
10779                 {
10780                         uint32_t _flags_save_string = ndr->flags;
10781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10782                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10783                         if (_ptr_architecture) {
10784                                 NDR_PULL_ALLOC(ndr, r->architecture);
10785                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10786                         } else {
10787                                 r->architecture = NULL;
10788                         }
10789                         ndr->flags = _flags_save_string;
10790                 }
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10795                         if (_ptr_driver_path) {
10796                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10797                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10798                         } else {
10799                                 r->driver_path = NULL;
10800                         }
10801                         ndr->flags = _flags_save_string;
10802                 }
10803                 {
10804                         uint32_t _flags_save_string = ndr->flags;
10805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10806                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10807                         if (_ptr_data_file) {
10808                                 NDR_PULL_ALLOC(ndr, r->data_file);
10809                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10810                         } else {
10811                                 r->data_file = NULL;
10812                         }
10813                         ndr->flags = _flags_save_string;
10814                 }
10815                 {
10816                         uint32_t _flags_save_string = ndr->flags;
10817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10818                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10819                         if (_ptr_config_file) {
10820                                 NDR_PULL_ALLOC(ndr, r->config_file);
10821                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10822                         } else {
10823                                 r->config_file = NULL;
10824                         }
10825                         ndr->flags = _flags_save_string;
10826                 }
10827                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10828         }
10829         if (ndr_flags & NDR_BUFFERS) {
10830                 {
10831                         uint32_t _flags_save_string = ndr->flags;
10832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10833                         if (r->driver_name) {
10834                                 uint32_t _relative_save_offset;
10835                                 _relative_save_offset = ndr->offset;
10836                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10837                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10838                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10839                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10840                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10841                                 if (ndr->offset > ndr->relative_highest_offset) {
10842                                         ndr->relative_highest_offset = ndr->offset;
10843                                 }
10844                                 ndr->offset = _relative_save_offset;
10845                         }
10846                         ndr->flags = _flags_save_string;
10847                 }
10848                 {
10849                         uint32_t _flags_save_string = ndr->flags;
10850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10851                         if (r->architecture) {
10852                                 uint32_t _relative_save_offset;
10853                                 _relative_save_offset = ndr->offset;
10854                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10855                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10856                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10857                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10858                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10859                                 if (ndr->offset > ndr->relative_highest_offset) {
10860                                         ndr->relative_highest_offset = ndr->offset;
10861                                 }
10862                                 ndr->offset = _relative_save_offset;
10863                         }
10864                         ndr->flags = _flags_save_string;
10865                 }
10866                 {
10867                         uint32_t _flags_save_string = ndr->flags;
10868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10869                         if (r->driver_path) {
10870                                 uint32_t _relative_save_offset;
10871                                 _relative_save_offset = ndr->offset;
10872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10873                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10874                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10877                                 if (ndr->offset > ndr->relative_highest_offset) {
10878                                         ndr->relative_highest_offset = ndr->offset;
10879                                 }
10880                                 ndr->offset = _relative_save_offset;
10881                         }
10882                         ndr->flags = _flags_save_string;
10883                 }
10884                 {
10885                         uint32_t _flags_save_string = ndr->flags;
10886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10887                         if (r->data_file) {
10888                                 uint32_t _relative_save_offset;
10889                                 _relative_save_offset = ndr->offset;
10890                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10891                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10892                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10893                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10894                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10895                                 if (ndr->offset > ndr->relative_highest_offset) {
10896                                         ndr->relative_highest_offset = ndr->offset;
10897                                 }
10898                                 ndr->offset = _relative_save_offset;
10899                         }
10900                         ndr->flags = _flags_save_string;
10901                 }
10902                 {
10903                         uint32_t _flags_save_string = ndr->flags;
10904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10905                         if (r->config_file) {
10906                                 uint32_t _relative_save_offset;
10907                                 _relative_save_offset = ndr->offset;
10908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10909                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10910                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10913                                 if (ndr->offset > ndr->relative_highest_offset) {
10914                                         ndr->relative_highest_offset = ndr->offset;
10915                                 }
10916                                 ndr->offset = _relative_save_offset;
10917                         }
10918                         ndr->flags = _flags_save_string;
10919                 }
10920         }
10921         return NDR_ERR_SUCCESS;
10922 }
10923
10924 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10925 {
10926         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10927         ndr->depth++;
10928         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10929         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10930         ndr->depth++;
10931         if (r->driver_name) {
10932                 ndr_print_string(ndr, "driver_name", r->driver_name);
10933         }
10934         ndr->depth--;
10935         ndr_print_ptr(ndr, "architecture", r->architecture);
10936         ndr->depth++;
10937         if (r->architecture) {
10938                 ndr_print_string(ndr, "architecture", r->architecture);
10939         }
10940         ndr->depth--;
10941         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10942         ndr->depth++;
10943         if (r->driver_path) {
10944                 ndr_print_string(ndr, "driver_path", r->driver_path);
10945         }
10946         ndr->depth--;
10947         ndr_print_ptr(ndr, "data_file", r->data_file);
10948         ndr->depth++;
10949         if (r->data_file) {
10950                 ndr_print_string(ndr, "data_file", r->data_file);
10951         }
10952         ndr->depth--;
10953         ndr_print_ptr(ndr, "config_file", r->config_file);
10954         ndr->depth++;
10955         if (r->config_file) {
10956                 ndr_print_string(ndr, "config_file", r->config_file);
10957         }
10958         ndr->depth--;
10959         ndr->depth--;
10960 }
10961
10962 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10963 {
10964         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10965 }
10966
10967 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10968 {
10969         if (ndr_flags & NDR_SCALARS) {
10970                 NDR_CHECK(ndr_push_align(ndr, 5));
10971                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10972                 {
10973                         uint32_t _flags_save_string = ndr->flags;
10974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10976                         ndr->flags = _flags_save_string;
10977                 }
10978                 {
10979                         uint32_t _flags_save_string = ndr->flags;
10980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10982                         ndr->flags = _flags_save_string;
10983                 }
10984                 {
10985                         uint32_t _flags_save_string = ndr->flags;
10986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10988                         ndr->flags = _flags_save_string;
10989                 }
10990                 {
10991                         uint32_t _flags_save_string = ndr->flags;
10992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10994                         ndr->flags = _flags_save_string;
10995                 }
10996                 {
10997                         uint32_t _flags_save_string = ndr->flags;
10998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10999                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11000                         ndr->flags = _flags_save_string;
11001                 }
11002                 {
11003                         uint32_t _flags_save_string = ndr->flags;
11004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11005                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11006                         ndr->flags = _flags_save_string;
11007                 }
11008                 {
11009                         uint32_t _flags_save_string_array = ndr->flags;
11010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11012                         ndr->flags = _flags_save_string_array;
11013                 }
11014                 {
11015                         uint32_t _flags_save_string = ndr->flags;
11016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11017                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11018                         ndr->flags = _flags_save_string;
11019                 }
11020                 {
11021                         uint32_t _flags_save_string = ndr->flags;
11022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11023                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11024                         ndr->flags = _flags_save_string;
11025                 }
11026                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11027         }
11028         if (ndr_flags & NDR_BUFFERS) {
11029                 {
11030                         uint32_t _flags_save_string = ndr->flags;
11031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11032                         if (r->driver_name) {
11033                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11034                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11035                         }
11036                         ndr->flags = _flags_save_string;
11037                 }
11038                 {
11039                         uint32_t _flags_save_string = ndr->flags;
11040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11041                         if (r->architecture) {
11042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11044                         }
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         if (r->driver_path) {
11051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11052                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11053                         }
11054                         ndr->flags = _flags_save_string;
11055                 }
11056                 {
11057                         uint32_t _flags_save_string = ndr->flags;
11058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11059                         if (r->data_file) {
11060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11062                         }
11063                         ndr->flags = _flags_save_string;
11064                 }
11065                 {
11066                         uint32_t _flags_save_string = ndr->flags;
11067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11068                         if (r->config_file) {
11069                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11070                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11071                         }
11072                         ndr->flags = _flags_save_string;
11073                 }
11074                 {
11075                         uint32_t _flags_save_string = ndr->flags;
11076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11077                         if (r->help_file) {
11078                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11079                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11080                         }
11081                         ndr->flags = _flags_save_string;
11082                 }
11083                 {
11084                         uint32_t _flags_save_string_array = ndr->flags;
11085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11086                         if (r->dependent_files) {
11087                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11088                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11089                         }
11090                         ndr->flags = _flags_save_string_array;
11091                 }
11092                 {
11093                         uint32_t _flags_save_string = ndr->flags;
11094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11095                         if (r->monitor_name) {
11096                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11097                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11098                         }
11099                         ndr->flags = _flags_save_string;
11100                 }
11101                 {
11102                         uint32_t _flags_save_string = ndr->flags;
11103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11104                         if (r->default_datatype) {
11105                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11106                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11107                         }
11108                         ndr->flags = _flags_save_string;
11109                 }
11110         }
11111         return NDR_ERR_SUCCESS;
11112 }
11113
11114 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11115 {
11116         uint32_t _ptr_driver_name;
11117         TALLOC_CTX *_mem_save_driver_name_0;
11118         uint32_t _ptr_architecture;
11119         TALLOC_CTX *_mem_save_architecture_0;
11120         uint32_t _ptr_driver_path;
11121         TALLOC_CTX *_mem_save_driver_path_0;
11122         uint32_t _ptr_data_file;
11123         TALLOC_CTX *_mem_save_data_file_0;
11124         uint32_t _ptr_config_file;
11125         TALLOC_CTX *_mem_save_config_file_0;
11126         uint32_t _ptr_help_file;
11127         TALLOC_CTX *_mem_save_help_file_0;
11128         uint32_t _ptr_dependent_files;
11129         TALLOC_CTX *_mem_save_dependent_files_0;
11130         uint32_t _ptr_monitor_name;
11131         TALLOC_CTX *_mem_save_monitor_name_0;
11132         uint32_t _ptr_default_datatype;
11133         TALLOC_CTX *_mem_save_default_datatype_0;
11134         if (ndr_flags & NDR_SCALARS) {
11135                 NDR_CHECK(ndr_pull_align(ndr, 5));
11136                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11137                 {
11138                         uint32_t _flags_save_string = ndr->flags;
11139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11140                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11141                         if (_ptr_driver_name) {
11142                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11143                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11144                         } else {
11145                                 r->driver_name = NULL;
11146                         }
11147                         ndr->flags = _flags_save_string;
11148                 }
11149                 {
11150                         uint32_t _flags_save_string = ndr->flags;
11151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11152                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11153                         if (_ptr_architecture) {
11154                                 NDR_PULL_ALLOC(ndr, r->architecture);
11155                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11156                         } else {
11157                                 r->architecture = NULL;
11158                         }
11159                         ndr->flags = _flags_save_string;
11160                 }
11161                 {
11162                         uint32_t _flags_save_string = ndr->flags;
11163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11164                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11165                         if (_ptr_driver_path) {
11166                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11167                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11168                         } else {
11169                                 r->driver_path = NULL;
11170                         }
11171                         ndr->flags = _flags_save_string;
11172                 }
11173                 {
11174                         uint32_t _flags_save_string = ndr->flags;
11175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11176                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11177                         if (_ptr_data_file) {
11178                                 NDR_PULL_ALLOC(ndr, r->data_file);
11179                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11180                         } else {
11181                                 r->data_file = NULL;
11182                         }
11183                         ndr->flags = _flags_save_string;
11184                 }
11185                 {
11186                         uint32_t _flags_save_string = ndr->flags;
11187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11188                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11189                         if (_ptr_config_file) {
11190                                 NDR_PULL_ALLOC(ndr, r->config_file);
11191                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11192                         } else {
11193                                 r->config_file = NULL;
11194                         }
11195                         ndr->flags = _flags_save_string;
11196                 }
11197                 {
11198                         uint32_t _flags_save_string = ndr->flags;
11199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11200                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11201                         if (_ptr_help_file) {
11202                                 NDR_PULL_ALLOC(ndr, r->help_file);
11203                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11204                         } else {
11205                                 r->help_file = NULL;
11206                         }
11207                         ndr->flags = _flags_save_string;
11208                 }
11209                 {
11210                         uint32_t _flags_save_string_array = ndr->flags;
11211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11212                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11213                         if (_ptr_dependent_files) {
11214                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11215                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11216                         } else {
11217                                 r->dependent_files = NULL;
11218                         }
11219                         ndr->flags = _flags_save_string_array;
11220                 }
11221                 {
11222                         uint32_t _flags_save_string = ndr->flags;
11223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11225                         if (_ptr_monitor_name) {
11226                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11228                         } else {
11229                                 r->monitor_name = NULL;
11230                         }
11231                         ndr->flags = _flags_save_string;
11232                 }
11233                 {
11234                         uint32_t _flags_save_string = ndr->flags;
11235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11237                         if (_ptr_default_datatype) {
11238                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11240                         } else {
11241                                 r->default_datatype = NULL;
11242                         }
11243                         ndr->flags = _flags_save_string;
11244                 }
11245                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11246         }
11247         if (ndr_flags & NDR_BUFFERS) {
11248                 {
11249                         uint32_t _flags_save_string = ndr->flags;
11250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11251                         if (r->driver_name) {
11252                                 uint32_t _relative_save_offset;
11253                                 _relative_save_offset = ndr->offset;
11254                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11255                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11256                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11257                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11258                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11259                                 if (ndr->offset > ndr->relative_highest_offset) {
11260                                         ndr->relative_highest_offset = ndr->offset;
11261                                 }
11262                                 ndr->offset = _relative_save_offset;
11263                         }
11264                         ndr->flags = _flags_save_string;
11265                 }
11266                 {
11267                         uint32_t _flags_save_string = ndr->flags;
11268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11269                         if (r->architecture) {
11270                                 uint32_t _relative_save_offset;
11271                                 _relative_save_offset = ndr->offset;
11272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11273                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11274                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11277                                 if (ndr->offset > ndr->relative_highest_offset) {
11278                                         ndr->relative_highest_offset = ndr->offset;
11279                                 }
11280                                 ndr->offset = _relative_save_offset;
11281                         }
11282                         ndr->flags = _flags_save_string;
11283                 }
11284                 {
11285                         uint32_t _flags_save_string = ndr->flags;
11286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11287                         if (r->driver_path) {
11288                                 uint32_t _relative_save_offset;
11289                                 _relative_save_offset = ndr->offset;
11290                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11291                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11292                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11293                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11294                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11295                                 if (ndr->offset > ndr->relative_highest_offset) {
11296                                         ndr->relative_highest_offset = ndr->offset;
11297                                 }
11298                                 ndr->offset = _relative_save_offset;
11299                         }
11300                         ndr->flags = _flags_save_string;
11301                 }
11302                 {
11303                         uint32_t _flags_save_string = ndr->flags;
11304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11305                         if (r->data_file) {
11306                                 uint32_t _relative_save_offset;
11307                                 _relative_save_offset = ndr->offset;
11308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11309                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11310                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11313                                 if (ndr->offset > ndr->relative_highest_offset) {
11314                                         ndr->relative_highest_offset = ndr->offset;
11315                                 }
11316                                 ndr->offset = _relative_save_offset;
11317                         }
11318                         ndr->flags = _flags_save_string;
11319                 }
11320                 {
11321                         uint32_t _flags_save_string = ndr->flags;
11322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11323                         if (r->config_file) {
11324                                 uint32_t _relative_save_offset;
11325                                 _relative_save_offset = ndr->offset;
11326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11327                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11328                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11331                                 if (ndr->offset > ndr->relative_highest_offset) {
11332                                         ndr->relative_highest_offset = ndr->offset;
11333                                 }
11334                                 ndr->offset = _relative_save_offset;
11335                         }
11336                         ndr->flags = _flags_save_string;
11337                 }
11338                 {
11339                         uint32_t _flags_save_string = ndr->flags;
11340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11341                         if (r->help_file) {
11342                                 uint32_t _relative_save_offset;
11343                                 _relative_save_offset = ndr->offset;
11344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11345                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11346                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11349                                 if (ndr->offset > ndr->relative_highest_offset) {
11350                                         ndr->relative_highest_offset = ndr->offset;
11351                                 }
11352                                 ndr->offset = _relative_save_offset;
11353                         }
11354                         ndr->flags = _flags_save_string;
11355                 }
11356                 {
11357                         uint32_t _flags_save_string_array = ndr->flags;
11358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11359                         if (r->dependent_files) {
11360                                 uint32_t _relative_save_offset;
11361                                 _relative_save_offset = ndr->offset;
11362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11363                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11364                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11365                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11367                                 if (ndr->offset > ndr->relative_highest_offset) {
11368                                         ndr->relative_highest_offset = ndr->offset;
11369                                 }
11370                                 ndr->offset = _relative_save_offset;
11371                         }
11372                         ndr->flags = _flags_save_string_array;
11373                 }
11374                 {
11375                         uint32_t _flags_save_string = ndr->flags;
11376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11377                         if (r->monitor_name) {
11378                                 uint32_t _relative_save_offset;
11379                                 _relative_save_offset = ndr->offset;
11380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11381                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11382                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11383                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11384                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11385                                 if (ndr->offset > ndr->relative_highest_offset) {
11386                                         ndr->relative_highest_offset = ndr->offset;
11387                                 }
11388                                 ndr->offset = _relative_save_offset;
11389                         }
11390                         ndr->flags = _flags_save_string;
11391                 }
11392                 {
11393                         uint32_t _flags_save_string = ndr->flags;
11394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11395                         if (r->default_datatype) {
11396                                 uint32_t _relative_save_offset;
11397                                 _relative_save_offset = ndr->offset;
11398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11399                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11400                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11403                                 if (ndr->offset > ndr->relative_highest_offset) {
11404                                         ndr->relative_highest_offset = ndr->offset;
11405                                 }
11406                                 ndr->offset = _relative_save_offset;
11407                         }
11408                         ndr->flags = _flags_save_string;
11409                 }
11410         }
11411         return NDR_ERR_SUCCESS;
11412 }
11413
11414 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11415 {
11416         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11417         ndr->depth++;
11418         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11419         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11420         ndr->depth++;
11421         if (r->driver_name) {
11422                 ndr_print_string(ndr, "driver_name", r->driver_name);
11423         }
11424         ndr->depth--;
11425         ndr_print_ptr(ndr, "architecture", r->architecture);
11426         ndr->depth++;
11427         if (r->architecture) {
11428                 ndr_print_string(ndr, "architecture", r->architecture);
11429         }
11430         ndr->depth--;
11431         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11432         ndr->depth++;
11433         if (r->driver_path) {
11434                 ndr_print_string(ndr, "driver_path", r->driver_path);
11435         }
11436         ndr->depth--;
11437         ndr_print_ptr(ndr, "data_file", r->data_file);
11438         ndr->depth++;
11439         if (r->data_file) {
11440                 ndr_print_string(ndr, "data_file", r->data_file);
11441         }
11442         ndr->depth--;
11443         ndr_print_ptr(ndr, "config_file", r->config_file);
11444         ndr->depth++;
11445         if (r->config_file) {
11446                 ndr_print_string(ndr, "config_file", r->config_file);
11447         }
11448         ndr->depth--;
11449         ndr_print_ptr(ndr, "help_file", r->help_file);
11450         ndr->depth++;
11451         if (r->help_file) {
11452                 ndr_print_string(ndr, "help_file", r->help_file);
11453         }
11454         ndr->depth--;
11455         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11456         ndr->depth++;
11457         if (r->dependent_files) {
11458                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11459         }
11460         ndr->depth--;
11461         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11462         ndr->depth++;
11463         if (r->monitor_name) {
11464                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11465         }
11466         ndr->depth--;
11467         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11468         ndr->depth++;
11469         if (r->default_datatype) {
11470                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11471         }
11472         ndr->depth--;
11473         ndr->depth--;
11474 }
11475
11476 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11477 {
11478         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11479 }
11480
11481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11482 {
11483         if (ndr_flags & NDR_SCALARS) {
11484                 NDR_CHECK(ndr_push_align(ndr, 5));
11485                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11486                 {
11487                         uint32_t _flags_save_string = ndr->flags;
11488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11490                         ndr->flags = _flags_save_string;
11491                 }
11492                 {
11493                         uint32_t _flags_save_string = ndr->flags;
11494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11496                         ndr->flags = _flags_save_string;
11497                 }
11498                 {
11499                         uint32_t _flags_save_string = ndr->flags;
11500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11502                         ndr->flags = _flags_save_string;
11503                 }
11504                 {
11505                         uint32_t _flags_save_string = ndr->flags;
11506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11508                         ndr->flags = _flags_save_string;
11509                 }
11510                 {
11511                         uint32_t _flags_save_string = ndr->flags;
11512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11514                         ndr->flags = _flags_save_string;
11515                 }
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11520                         ndr->flags = _flags_save_string;
11521                 }
11522                 {
11523                         uint32_t _flags_save_string_array = ndr->flags;
11524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11526                         ndr->flags = _flags_save_string_array;
11527                 }
11528                 {
11529                         uint32_t _flags_save_string = ndr->flags;
11530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11538                         ndr->flags = _flags_save_string;
11539                 }
11540                 {
11541                         uint32_t _flags_save_string_array = ndr->flags;
11542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11544                         ndr->flags = _flags_save_string_array;
11545                 }
11546                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11547         }
11548         if (ndr_flags & NDR_BUFFERS) {
11549                 {
11550                         uint32_t _flags_save_string = ndr->flags;
11551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11552                         if (r->driver_name) {
11553                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11554                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11555                         }
11556                         ndr->flags = _flags_save_string;
11557                 }
11558                 {
11559                         uint32_t _flags_save_string = ndr->flags;
11560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11561                         if (r->architecture) {
11562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11564                         }
11565                         ndr->flags = _flags_save_string;
11566                 }
11567                 {
11568                         uint32_t _flags_save_string = ndr->flags;
11569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11570                         if (r->driver_path) {
11571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11573                         }
11574                         ndr->flags = _flags_save_string;
11575                 }
11576                 {
11577                         uint32_t _flags_save_string = ndr->flags;
11578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11579                         if (r->data_file) {
11580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11582                         }
11583                         ndr->flags = _flags_save_string;
11584                 }
11585                 {
11586                         uint32_t _flags_save_string = ndr->flags;
11587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11588                         if (r->config_file) {
11589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11591                         }
11592                         ndr->flags = _flags_save_string;
11593                 }
11594                 {
11595                         uint32_t _flags_save_string = ndr->flags;
11596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11597                         if (r->help_file) {
11598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11600                         }
11601                         ndr->flags = _flags_save_string;
11602                 }
11603                 {
11604                         uint32_t _flags_save_string_array = ndr->flags;
11605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11606                         if (r->dependent_files) {
11607                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11608                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11609                         }
11610                         ndr->flags = _flags_save_string_array;
11611                 }
11612                 {
11613                         uint32_t _flags_save_string = ndr->flags;
11614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11615                         if (r->monitor_name) {
11616                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11617                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11618                         }
11619                         ndr->flags = _flags_save_string;
11620                 }
11621                 {
11622                         uint32_t _flags_save_string = ndr->flags;
11623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11624                         if (r->default_datatype) {
11625                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11626                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11627                         }
11628                         ndr->flags = _flags_save_string;
11629                 }
11630                 {
11631                         uint32_t _flags_save_string_array = ndr->flags;
11632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11633                         if (r->previous_names) {
11634                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11635                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11636                         }
11637                         ndr->flags = _flags_save_string_array;
11638                 }
11639         }
11640         return NDR_ERR_SUCCESS;
11641 }
11642
11643 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11644 {
11645         uint32_t _ptr_driver_name;
11646         TALLOC_CTX *_mem_save_driver_name_0;
11647         uint32_t _ptr_architecture;
11648         TALLOC_CTX *_mem_save_architecture_0;
11649         uint32_t _ptr_driver_path;
11650         TALLOC_CTX *_mem_save_driver_path_0;
11651         uint32_t _ptr_data_file;
11652         TALLOC_CTX *_mem_save_data_file_0;
11653         uint32_t _ptr_config_file;
11654         TALLOC_CTX *_mem_save_config_file_0;
11655         uint32_t _ptr_help_file;
11656         TALLOC_CTX *_mem_save_help_file_0;
11657         uint32_t _ptr_dependent_files;
11658         TALLOC_CTX *_mem_save_dependent_files_0;
11659         uint32_t _ptr_monitor_name;
11660         TALLOC_CTX *_mem_save_monitor_name_0;
11661         uint32_t _ptr_default_datatype;
11662         TALLOC_CTX *_mem_save_default_datatype_0;
11663         uint32_t _ptr_previous_names;
11664         TALLOC_CTX *_mem_save_previous_names_0;
11665         if (ndr_flags & NDR_SCALARS) {
11666                 NDR_CHECK(ndr_pull_align(ndr, 5));
11667                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11668                 {
11669                         uint32_t _flags_save_string = ndr->flags;
11670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11671                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11672                         if (_ptr_driver_name) {
11673                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11674                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11675                         } else {
11676                                 r->driver_name = NULL;
11677                         }
11678                         ndr->flags = _flags_save_string;
11679                 }
11680                 {
11681                         uint32_t _flags_save_string = ndr->flags;
11682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11683                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11684                         if (_ptr_architecture) {
11685                                 NDR_PULL_ALLOC(ndr, r->architecture);
11686                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11687                         } else {
11688                                 r->architecture = NULL;
11689                         }
11690                         ndr->flags = _flags_save_string;
11691                 }
11692                 {
11693                         uint32_t _flags_save_string = ndr->flags;
11694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11695                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11696                         if (_ptr_driver_path) {
11697                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11698                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11699                         } else {
11700                                 r->driver_path = NULL;
11701                         }
11702                         ndr->flags = _flags_save_string;
11703                 }
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11708                         if (_ptr_data_file) {
11709                                 NDR_PULL_ALLOC(ndr, r->data_file);
11710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11711                         } else {
11712                                 r->data_file = NULL;
11713                         }
11714                         ndr->flags = _flags_save_string;
11715                 }
11716                 {
11717                         uint32_t _flags_save_string = ndr->flags;
11718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11720                         if (_ptr_config_file) {
11721                                 NDR_PULL_ALLOC(ndr, r->config_file);
11722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11723                         } else {
11724                                 r->config_file = NULL;
11725                         }
11726                         ndr->flags = _flags_save_string;
11727                 }
11728                 {
11729                         uint32_t _flags_save_string = ndr->flags;
11730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11732                         if (_ptr_help_file) {
11733                                 NDR_PULL_ALLOC(ndr, r->help_file);
11734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11735                         } else {
11736                                 r->help_file = NULL;
11737                         }
11738                         ndr->flags = _flags_save_string;
11739                 }
11740                 {
11741                         uint32_t _flags_save_string_array = ndr->flags;
11742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11744                         if (_ptr_dependent_files) {
11745                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11747                         } else {
11748                                 r->dependent_files = NULL;
11749                         }
11750                         ndr->flags = _flags_save_string_array;
11751                 }
11752                 {
11753                         uint32_t _flags_save_string = ndr->flags;
11754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11756                         if (_ptr_monitor_name) {
11757                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11759                         } else {
11760                                 r->monitor_name = NULL;
11761                         }
11762                         ndr->flags = _flags_save_string;
11763                 }
11764                 {
11765                         uint32_t _flags_save_string = ndr->flags;
11766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11768                         if (_ptr_default_datatype) {
11769                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11771                         } else {
11772                                 r->default_datatype = NULL;
11773                         }
11774                         ndr->flags = _flags_save_string;
11775                 }
11776                 {
11777                         uint32_t _flags_save_string_array = ndr->flags;
11778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11780                         if (_ptr_previous_names) {
11781                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11783                         } else {
11784                                 r->previous_names = NULL;
11785                         }
11786                         ndr->flags = _flags_save_string_array;
11787                 }
11788                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11789         }
11790         if (ndr_flags & NDR_BUFFERS) {
11791                 {
11792                         uint32_t _flags_save_string = ndr->flags;
11793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11794                         if (r->driver_name) {
11795                                 uint32_t _relative_save_offset;
11796                                 _relative_save_offset = ndr->offset;
11797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11798                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11799                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11802                                 if (ndr->offset > ndr->relative_highest_offset) {
11803                                         ndr->relative_highest_offset = ndr->offset;
11804                                 }
11805                                 ndr->offset = _relative_save_offset;
11806                         }
11807                         ndr->flags = _flags_save_string;
11808                 }
11809                 {
11810                         uint32_t _flags_save_string = ndr->flags;
11811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11812                         if (r->architecture) {
11813                                 uint32_t _relative_save_offset;
11814                                 _relative_save_offset = ndr->offset;
11815                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11816                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11817                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11818                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11819                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11820                                 if (ndr->offset > ndr->relative_highest_offset) {
11821                                         ndr->relative_highest_offset = ndr->offset;
11822                                 }
11823                                 ndr->offset = _relative_save_offset;
11824                         }
11825                         ndr->flags = _flags_save_string;
11826                 }
11827                 {
11828                         uint32_t _flags_save_string = ndr->flags;
11829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11830                         if (r->driver_path) {
11831                                 uint32_t _relative_save_offset;
11832                                 _relative_save_offset = ndr->offset;
11833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11834                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11835                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11838                                 if (ndr->offset > ndr->relative_highest_offset) {
11839                                         ndr->relative_highest_offset = ndr->offset;
11840                                 }
11841                                 ndr->offset = _relative_save_offset;
11842                         }
11843                         ndr->flags = _flags_save_string;
11844                 }
11845                 {
11846                         uint32_t _flags_save_string = ndr->flags;
11847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11848                         if (r->data_file) {
11849                                 uint32_t _relative_save_offset;
11850                                 _relative_save_offset = ndr->offset;
11851                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11852                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11853                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11854                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11855                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11856                                 if (ndr->offset > ndr->relative_highest_offset) {
11857                                         ndr->relative_highest_offset = ndr->offset;
11858                                 }
11859                                 ndr->offset = _relative_save_offset;
11860                         }
11861                         ndr->flags = _flags_save_string;
11862                 }
11863                 {
11864                         uint32_t _flags_save_string = ndr->flags;
11865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11866                         if (r->config_file) {
11867                                 uint32_t _relative_save_offset;
11868                                 _relative_save_offset = ndr->offset;
11869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11870                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11871                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11872                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11874                                 if (ndr->offset > ndr->relative_highest_offset) {
11875                                         ndr->relative_highest_offset = ndr->offset;
11876                                 }
11877                                 ndr->offset = _relative_save_offset;
11878                         }
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         if (r->help_file) {
11885                                 uint32_t _relative_save_offset;
11886                                 _relative_save_offset = ndr->offset;
11887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11888                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11889                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11892                                 if (ndr->offset > ndr->relative_highest_offset) {
11893                                         ndr->relative_highest_offset = ndr->offset;
11894                                 }
11895                                 ndr->offset = _relative_save_offset;
11896                         }
11897                         ndr->flags = _flags_save_string;
11898                 }
11899                 {
11900                         uint32_t _flags_save_string_array = ndr->flags;
11901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11902                         if (r->dependent_files) {
11903                                 uint32_t _relative_save_offset;
11904                                 _relative_save_offset = ndr->offset;
11905                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11906                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11907                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11908                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11909                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11910                                 if (ndr->offset > ndr->relative_highest_offset) {
11911                                         ndr->relative_highest_offset = ndr->offset;
11912                                 }
11913                                 ndr->offset = _relative_save_offset;
11914                         }
11915                         ndr->flags = _flags_save_string_array;
11916                 }
11917                 {
11918                         uint32_t _flags_save_string = ndr->flags;
11919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11920                         if (r->monitor_name) {
11921                                 uint32_t _relative_save_offset;
11922                                 _relative_save_offset = ndr->offset;
11923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11924                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11925                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11928                                 if (ndr->offset > ndr->relative_highest_offset) {
11929                                         ndr->relative_highest_offset = ndr->offset;
11930                                 }
11931                                 ndr->offset = _relative_save_offset;
11932                         }
11933                         ndr->flags = _flags_save_string;
11934                 }
11935                 {
11936                         uint32_t _flags_save_string = ndr->flags;
11937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11938                         if (r->default_datatype) {
11939                                 uint32_t _relative_save_offset;
11940                                 _relative_save_offset = ndr->offset;
11941                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11942                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11943                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11944                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11945                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11946                                 if (ndr->offset > ndr->relative_highest_offset) {
11947                                         ndr->relative_highest_offset = ndr->offset;
11948                                 }
11949                                 ndr->offset = _relative_save_offset;
11950                         }
11951                         ndr->flags = _flags_save_string;
11952                 }
11953                 {
11954                         uint32_t _flags_save_string_array = ndr->flags;
11955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11956                         if (r->previous_names) {
11957                                 uint32_t _relative_save_offset;
11958                                 _relative_save_offset = ndr->offset;
11959                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11960                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11961                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11962                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11963                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11964                                 if (ndr->offset > ndr->relative_highest_offset) {
11965                                         ndr->relative_highest_offset = ndr->offset;
11966                                 }
11967                                 ndr->offset = _relative_save_offset;
11968                         }
11969                         ndr->flags = _flags_save_string_array;
11970                 }
11971         }
11972         return NDR_ERR_SUCCESS;
11973 }
11974
11975 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11976 {
11977         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11978         ndr->depth++;
11979         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11980         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11981         ndr->depth++;
11982         if (r->driver_name) {
11983                 ndr_print_string(ndr, "driver_name", r->driver_name);
11984         }
11985         ndr->depth--;
11986         ndr_print_ptr(ndr, "architecture", r->architecture);
11987         ndr->depth++;
11988         if (r->architecture) {
11989                 ndr_print_string(ndr, "architecture", r->architecture);
11990         }
11991         ndr->depth--;
11992         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11993         ndr->depth++;
11994         if (r->driver_path) {
11995                 ndr_print_string(ndr, "driver_path", r->driver_path);
11996         }
11997         ndr->depth--;
11998         ndr_print_ptr(ndr, "data_file", r->data_file);
11999         ndr->depth++;
12000         if (r->data_file) {
12001                 ndr_print_string(ndr, "data_file", r->data_file);
12002         }
12003         ndr->depth--;
12004         ndr_print_ptr(ndr, "config_file", r->config_file);
12005         ndr->depth++;
12006         if (r->config_file) {
12007                 ndr_print_string(ndr, "config_file", r->config_file);
12008         }
12009         ndr->depth--;
12010         ndr_print_ptr(ndr, "help_file", r->help_file);
12011         ndr->depth++;
12012         if (r->help_file) {
12013                 ndr_print_string(ndr, "help_file", r->help_file);
12014         }
12015         ndr->depth--;
12016         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12017         ndr->depth++;
12018         if (r->dependent_files) {
12019                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12020         }
12021         ndr->depth--;
12022         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12023         ndr->depth++;
12024         if (r->monitor_name) {
12025                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12026         }
12027         ndr->depth--;
12028         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12029         ndr->depth++;
12030         if (r->default_datatype) {
12031                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12032         }
12033         ndr->depth--;
12034         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12035         ndr->depth++;
12036         if (r->previous_names) {
12037                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12038         }
12039         ndr->depth--;
12040         ndr->depth--;
12041 }
12042
12043 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12044 {
12045         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12046 }
12047
12048 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12049 {
12050         if (ndr_flags & NDR_SCALARS) {
12051                 NDR_CHECK(ndr_push_align(ndr, 5));
12052                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12053                 {
12054                         uint32_t _flags_save_string = ndr->flags;
12055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12057                         ndr->flags = _flags_save_string;
12058                 }
12059                 {
12060                         uint32_t _flags_save_string = ndr->flags;
12061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12062                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12063                         ndr->flags = _flags_save_string;
12064                 }
12065                 {
12066                         uint32_t _flags_save_string = ndr->flags;
12067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12068                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12069                         ndr->flags = _flags_save_string;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12075                         ndr->flags = _flags_save_string;
12076                 }
12077                 {
12078                         uint32_t _flags_save_string = ndr->flags;
12079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12080                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12081                         ndr->flags = _flags_save_string;
12082                 }
12083                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12086                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12087         }
12088         if (ndr_flags & NDR_BUFFERS) {
12089                 {
12090                         uint32_t _flags_save_string = ndr->flags;
12091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12092                         if (r->driver_name) {
12093                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12094                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12095                         }
12096                         ndr->flags = _flags_save_string;
12097                 }
12098                 {
12099                         uint32_t _flags_save_string = ndr->flags;
12100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12101                         if (r->architecture) {
12102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12104                         }
12105                         ndr->flags = _flags_save_string;
12106                 }
12107                 {
12108                         uint32_t _flags_save_string = ndr->flags;
12109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12110                         if (r->driver_path) {
12111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12113                         }
12114                         ndr->flags = _flags_save_string;
12115                 }
12116                 {
12117                         uint32_t _flags_save_string = ndr->flags;
12118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12119                         if (r->data_file) {
12120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12122                         }
12123                         ndr->flags = _flags_save_string;
12124                 }
12125                 {
12126                         uint32_t _flags_save_string = ndr->flags;
12127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12128                         if (r->config_file) {
12129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12131                         }
12132                         ndr->flags = _flags_save_string;
12133                 }
12134         }
12135         return NDR_ERR_SUCCESS;
12136 }
12137
12138 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12139 {
12140         uint32_t _ptr_driver_name;
12141         TALLOC_CTX *_mem_save_driver_name_0;
12142         uint32_t _ptr_architecture;
12143         TALLOC_CTX *_mem_save_architecture_0;
12144         uint32_t _ptr_driver_path;
12145         TALLOC_CTX *_mem_save_driver_path_0;
12146         uint32_t _ptr_data_file;
12147         TALLOC_CTX *_mem_save_data_file_0;
12148         uint32_t _ptr_config_file;
12149         TALLOC_CTX *_mem_save_config_file_0;
12150         if (ndr_flags & NDR_SCALARS) {
12151                 NDR_CHECK(ndr_pull_align(ndr, 5));
12152                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12153                 {
12154                         uint32_t _flags_save_string = ndr->flags;
12155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12156                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12157                         if (_ptr_driver_name) {
12158                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12159                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12160                         } else {
12161                                 r->driver_name = NULL;
12162                         }
12163                         ndr->flags = _flags_save_string;
12164                 }
12165                 {
12166                         uint32_t _flags_save_string = ndr->flags;
12167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12168                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12169                         if (_ptr_architecture) {
12170                                 NDR_PULL_ALLOC(ndr, r->architecture);
12171                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12172                         } else {
12173                                 r->architecture = NULL;
12174                         }
12175                         ndr->flags = _flags_save_string;
12176                 }
12177                 {
12178                         uint32_t _flags_save_string = ndr->flags;
12179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12181                         if (_ptr_driver_path) {
12182                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12184                         } else {
12185                                 r->driver_path = NULL;
12186                         }
12187                         ndr->flags = _flags_save_string;
12188                 }
12189                 {
12190                         uint32_t _flags_save_string = ndr->flags;
12191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12193                         if (_ptr_data_file) {
12194                                 NDR_PULL_ALLOC(ndr, r->data_file);
12195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12196                         } else {
12197                                 r->data_file = NULL;
12198                         }
12199                         ndr->flags = _flags_save_string;
12200                 }
12201                 {
12202                         uint32_t _flags_save_string = ndr->flags;
12203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12205                         if (_ptr_config_file) {
12206                                 NDR_PULL_ALLOC(ndr, r->config_file);
12207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12208                         } else {
12209                                 r->config_file = NULL;
12210                         }
12211                         ndr->flags = _flags_save_string;
12212                 }
12213                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12216                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12217         }
12218         if (ndr_flags & NDR_BUFFERS) {
12219                 {
12220                         uint32_t _flags_save_string = ndr->flags;
12221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12222                         if (r->driver_name) {
12223                                 uint32_t _relative_save_offset;
12224                                 _relative_save_offset = ndr->offset;
12225                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12226                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12227                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12228                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12229                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12230                                 if (ndr->offset > ndr->relative_highest_offset) {
12231                                         ndr->relative_highest_offset = ndr->offset;
12232                                 }
12233                                 ndr->offset = _relative_save_offset;
12234                         }
12235                         ndr->flags = _flags_save_string;
12236                 }
12237                 {
12238                         uint32_t _flags_save_string = ndr->flags;
12239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12240                         if (r->architecture) {
12241                                 uint32_t _relative_save_offset;
12242                                 _relative_save_offset = ndr->offset;
12243                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12244                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12245                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12246                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12247                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12248                                 if (ndr->offset > ndr->relative_highest_offset) {
12249                                         ndr->relative_highest_offset = ndr->offset;
12250                                 }
12251                                 ndr->offset = _relative_save_offset;
12252                         }
12253                         ndr->flags = _flags_save_string;
12254                 }
12255                 {
12256                         uint32_t _flags_save_string = ndr->flags;
12257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12258                         if (r->driver_path) {
12259                                 uint32_t _relative_save_offset;
12260                                 _relative_save_offset = ndr->offset;
12261                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12262                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12263                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12264                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12265                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12266                                 if (ndr->offset > ndr->relative_highest_offset) {
12267                                         ndr->relative_highest_offset = ndr->offset;
12268                                 }
12269                                 ndr->offset = _relative_save_offset;
12270                         }
12271                         ndr->flags = _flags_save_string;
12272                 }
12273                 {
12274                         uint32_t _flags_save_string = ndr->flags;
12275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12276                         if (r->data_file) {
12277                                 uint32_t _relative_save_offset;
12278                                 _relative_save_offset = ndr->offset;
12279                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12280                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12281                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12282                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12283                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12284                                 if (ndr->offset > ndr->relative_highest_offset) {
12285                                         ndr->relative_highest_offset = ndr->offset;
12286                                 }
12287                                 ndr->offset = _relative_save_offset;
12288                         }
12289                         ndr->flags = _flags_save_string;
12290                 }
12291                 {
12292                         uint32_t _flags_save_string = ndr->flags;
12293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12294                         if (r->config_file) {
12295                                 uint32_t _relative_save_offset;
12296                                 _relative_save_offset = ndr->offset;
12297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12298                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12299                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12302                                 if (ndr->offset > ndr->relative_highest_offset) {
12303                                         ndr->relative_highest_offset = ndr->offset;
12304                                 }
12305                                 ndr->offset = _relative_save_offset;
12306                         }
12307                         ndr->flags = _flags_save_string;
12308                 }
12309         }
12310         return NDR_ERR_SUCCESS;
12311 }
12312
12313 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12314 {
12315         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12316         ndr->depth++;
12317         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12318         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12319         ndr->depth++;
12320         if (r->driver_name) {
12321                 ndr_print_string(ndr, "driver_name", r->driver_name);
12322         }
12323         ndr->depth--;
12324         ndr_print_ptr(ndr, "architecture", r->architecture);
12325         ndr->depth++;
12326         if (r->architecture) {
12327                 ndr_print_string(ndr, "architecture", r->architecture);
12328         }
12329         ndr->depth--;
12330         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12331         ndr->depth++;
12332         if (r->driver_path) {
12333                 ndr_print_string(ndr, "driver_path", r->driver_path);
12334         }
12335         ndr->depth--;
12336         ndr_print_ptr(ndr, "data_file", r->data_file);
12337         ndr->depth++;
12338         if (r->data_file) {
12339                 ndr_print_string(ndr, "data_file", r->data_file);
12340         }
12341         ndr->depth--;
12342         ndr_print_ptr(ndr, "config_file", r->config_file);
12343         ndr->depth++;
12344         if (r->config_file) {
12345                 ndr_print_string(ndr, "config_file", r->config_file);
12346         }
12347         ndr->depth--;
12348         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12349         ndr_print_uint32(ndr, "config_version", r->config_version);
12350         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12351         ndr->depth--;
12352 }
12353
12354 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12355 {
12356         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12357 }
12358
12359 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12360 {
12361         if (ndr_flags & NDR_SCALARS) {
12362                 NDR_CHECK(ndr_push_align(ndr, 8));
12363                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12364                 {
12365                         uint32_t _flags_save_string = ndr->flags;
12366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12367                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12368                         ndr->flags = _flags_save_string;
12369                 }
12370                 {
12371                         uint32_t _flags_save_string = ndr->flags;
12372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12373                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12374                         ndr->flags = _flags_save_string;
12375                 }
12376                 {
12377                         uint32_t _flags_save_string = ndr->flags;
12378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12379                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12380                         ndr->flags = _flags_save_string;
12381                 }
12382                 {
12383                         uint32_t _flags_save_string = ndr->flags;
12384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12385                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12386                         ndr->flags = _flags_save_string;
12387                 }
12388                 {
12389                         uint32_t _flags_save_string = ndr->flags;
12390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12391                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12392                         ndr->flags = _flags_save_string;
12393                 }
12394                 {
12395                         uint32_t _flags_save_string = ndr->flags;
12396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12397                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12398                         ndr->flags = _flags_save_string;
12399                 }
12400                 {
12401                         uint32_t _flags_save_string_array = ndr->flags;
12402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12403                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12404                         ndr->flags = _flags_save_string_array;
12405                 }
12406                 {
12407                         uint32_t _flags_save_string = ndr->flags;
12408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12409                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12410                         ndr->flags = _flags_save_string;
12411                 }
12412                 {
12413                         uint32_t _flags_save_string = ndr->flags;
12414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12415                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12416                         ndr->flags = _flags_save_string;
12417                 }
12418                 {
12419                         uint32_t _flags_save_string_array = ndr->flags;
12420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12421                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12422                         ndr->flags = _flags_save_string_array;
12423                 }
12424                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12425                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12426                 {
12427                         uint32_t _flags_save_string = ndr->flags;
12428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12429                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12436                         ndr->flags = _flags_save_string;
12437                 }
12438                 {
12439                         uint32_t _flags_save_string = ndr->flags;
12440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12441                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12442                         ndr->flags = _flags_save_string;
12443                 }
12444                 {
12445                         uint32_t _flags_save_string = ndr->flags;
12446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12447                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12448                         ndr->flags = _flags_save_string;
12449                 }
12450                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12451         }
12452         if (ndr_flags & NDR_BUFFERS) {
12453                 {
12454                         uint32_t _flags_save_string = ndr->flags;
12455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12456                         if (r->driver_name) {
12457                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12458                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12459                         }
12460                         ndr->flags = _flags_save_string;
12461                 }
12462                 {
12463                         uint32_t _flags_save_string = ndr->flags;
12464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12465                         if (r->architecture) {
12466                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12467                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12468                         }
12469                         ndr->flags = _flags_save_string;
12470                 }
12471                 {
12472                         uint32_t _flags_save_string = ndr->flags;
12473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12474                         if (r->driver_path) {
12475                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12476                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12477                         }
12478                         ndr->flags = _flags_save_string;
12479                 }
12480                 {
12481                         uint32_t _flags_save_string = ndr->flags;
12482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12483                         if (r->data_file) {
12484                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12485                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12486                         }
12487                         ndr->flags = _flags_save_string;
12488                 }
12489                 {
12490                         uint32_t _flags_save_string = ndr->flags;
12491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12492                         if (r->config_file) {
12493                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12494                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12495                         }
12496                         ndr->flags = _flags_save_string;
12497                 }
12498                 {
12499                         uint32_t _flags_save_string = ndr->flags;
12500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12501                         if (r->help_file) {
12502                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12503                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12504                         }
12505                         ndr->flags = _flags_save_string;
12506                 }
12507                 {
12508                         uint32_t _flags_save_string_array = ndr->flags;
12509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12510                         if (r->dependent_files) {
12511                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12512                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12513                         }
12514                         ndr->flags = _flags_save_string_array;
12515                 }
12516                 {
12517                         uint32_t _flags_save_string = ndr->flags;
12518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12519                         if (r->monitor_name) {
12520                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12521                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12522                         }
12523                         ndr->flags = _flags_save_string;
12524                 }
12525                 {
12526                         uint32_t _flags_save_string = ndr->flags;
12527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12528                         if (r->default_datatype) {
12529                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12530                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12531                         }
12532                         ndr->flags = _flags_save_string;
12533                 }
12534                 {
12535                         uint32_t _flags_save_string_array = ndr->flags;
12536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12537                         if (r->previous_names) {
12538                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12539                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12540                         }
12541                         ndr->flags = _flags_save_string_array;
12542                 }
12543                 {
12544                         uint32_t _flags_save_string = ndr->flags;
12545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12546                         if (r->manufacturer_name) {
12547                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12548                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12549                         }
12550                         ndr->flags = _flags_save_string;
12551                 }
12552                 {
12553                         uint32_t _flags_save_string = ndr->flags;
12554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12555                         if (r->manufacturer_url) {
12556                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12557                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12558                         }
12559                         ndr->flags = _flags_save_string;
12560                 }
12561                 {
12562                         uint32_t _flags_save_string = ndr->flags;
12563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12564                         if (r->hardware_id) {
12565                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12566                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12567                         }
12568                         ndr->flags = _flags_save_string;
12569                 }
12570                 {
12571                         uint32_t _flags_save_string = ndr->flags;
12572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12573                         if (r->provider) {
12574                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12575                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12576                         }
12577                         ndr->flags = _flags_save_string;
12578                 }
12579         }
12580         return NDR_ERR_SUCCESS;
12581 }
12582
12583 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12584 {
12585         uint32_t _ptr_driver_name;
12586         TALLOC_CTX *_mem_save_driver_name_0;
12587         uint32_t _ptr_architecture;
12588         TALLOC_CTX *_mem_save_architecture_0;
12589         uint32_t _ptr_driver_path;
12590         TALLOC_CTX *_mem_save_driver_path_0;
12591         uint32_t _ptr_data_file;
12592         TALLOC_CTX *_mem_save_data_file_0;
12593         uint32_t _ptr_config_file;
12594         TALLOC_CTX *_mem_save_config_file_0;
12595         uint32_t _ptr_help_file;
12596         TALLOC_CTX *_mem_save_help_file_0;
12597         uint32_t _ptr_dependent_files;
12598         TALLOC_CTX *_mem_save_dependent_files_0;
12599         uint32_t _ptr_monitor_name;
12600         TALLOC_CTX *_mem_save_monitor_name_0;
12601         uint32_t _ptr_default_datatype;
12602         TALLOC_CTX *_mem_save_default_datatype_0;
12603         uint32_t _ptr_previous_names;
12604         TALLOC_CTX *_mem_save_previous_names_0;
12605         uint32_t _ptr_manufacturer_name;
12606         TALLOC_CTX *_mem_save_manufacturer_name_0;
12607         uint32_t _ptr_manufacturer_url;
12608         TALLOC_CTX *_mem_save_manufacturer_url_0;
12609         uint32_t _ptr_hardware_id;
12610         TALLOC_CTX *_mem_save_hardware_id_0;
12611         uint32_t _ptr_provider;
12612         TALLOC_CTX *_mem_save_provider_0;
12613         if (ndr_flags & NDR_SCALARS) {
12614                 NDR_CHECK(ndr_pull_align(ndr, 8));
12615                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12616                 {
12617                         uint32_t _flags_save_string = ndr->flags;
12618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12619                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12620                         if (_ptr_driver_name) {
12621                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12622                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12623                         } else {
12624                                 r->driver_name = NULL;
12625                         }
12626                         ndr->flags = _flags_save_string;
12627                 }
12628                 {
12629                         uint32_t _flags_save_string = ndr->flags;
12630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12631                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12632                         if (_ptr_architecture) {
12633                                 NDR_PULL_ALLOC(ndr, r->architecture);
12634                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12635                         } else {
12636                                 r->architecture = NULL;
12637                         }
12638                         ndr->flags = _flags_save_string;
12639                 }
12640                 {
12641                         uint32_t _flags_save_string = ndr->flags;
12642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12643                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12644                         if (_ptr_driver_path) {
12645                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12646                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12647                         } else {
12648                                 r->driver_path = NULL;
12649                         }
12650                         ndr->flags = _flags_save_string;
12651                 }
12652                 {
12653                         uint32_t _flags_save_string = ndr->flags;
12654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12655                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12656                         if (_ptr_data_file) {
12657                                 NDR_PULL_ALLOC(ndr, r->data_file);
12658                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12659                         } else {
12660                                 r->data_file = NULL;
12661                         }
12662                         ndr->flags = _flags_save_string;
12663                 }
12664                 {
12665                         uint32_t _flags_save_string = ndr->flags;
12666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12667                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12668                         if (_ptr_config_file) {
12669                                 NDR_PULL_ALLOC(ndr, r->config_file);
12670                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12671                         } else {
12672                                 r->config_file = NULL;
12673                         }
12674                         ndr->flags = _flags_save_string;
12675                 }
12676                 {
12677                         uint32_t _flags_save_string = ndr->flags;
12678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12679                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12680                         if (_ptr_help_file) {
12681                                 NDR_PULL_ALLOC(ndr, r->help_file);
12682                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12683                         } else {
12684                                 r->help_file = NULL;
12685                         }
12686                         ndr->flags = _flags_save_string;
12687                 }
12688                 {
12689                         uint32_t _flags_save_string_array = ndr->flags;
12690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12691                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12692                         if (_ptr_dependent_files) {
12693                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12694                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12695                         } else {
12696                                 r->dependent_files = NULL;
12697                         }
12698                         ndr->flags = _flags_save_string_array;
12699                 }
12700                 {
12701                         uint32_t _flags_save_string = ndr->flags;
12702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12704                         if (_ptr_monitor_name) {
12705                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12707                         } else {
12708                                 r->monitor_name = NULL;
12709                         }
12710                         ndr->flags = _flags_save_string;
12711                 }
12712                 {
12713                         uint32_t _flags_save_string = ndr->flags;
12714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12716                         if (_ptr_default_datatype) {
12717                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12719                         } else {
12720                                 r->default_datatype = NULL;
12721                         }
12722                         ndr->flags = _flags_save_string;
12723                 }
12724                 {
12725                         uint32_t _flags_save_string_array = ndr->flags;
12726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12728                         if (_ptr_previous_names) {
12729                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12731                         } else {
12732                                 r->previous_names = NULL;
12733                         }
12734                         ndr->flags = _flags_save_string_array;
12735                 }
12736                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12737                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12738                 {
12739                         uint32_t _flags_save_string = ndr->flags;
12740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12742                         if (_ptr_manufacturer_name) {
12743                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12745                         } else {
12746                                 r->manufacturer_name = NULL;
12747                         }
12748                         ndr->flags = _flags_save_string;
12749                 }
12750                 {
12751                         uint32_t _flags_save_string = ndr->flags;
12752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12754                         if (_ptr_manufacturer_url) {
12755                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12757                         } else {
12758                                 r->manufacturer_url = NULL;
12759                         }
12760                         ndr->flags = _flags_save_string;
12761                 }
12762                 {
12763                         uint32_t _flags_save_string = ndr->flags;
12764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12766                         if (_ptr_hardware_id) {
12767                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12769                         } else {
12770                                 r->hardware_id = NULL;
12771                         }
12772                         ndr->flags = _flags_save_string;
12773                 }
12774                 {
12775                         uint32_t _flags_save_string = ndr->flags;
12776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12777                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12778                         if (_ptr_provider) {
12779                                 NDR_PULL_ALLOC(ndr, r->provider);
12780                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12781                         } else {
12782                                 r->provider = NULL;
12783                         }
12784                         ndr->flags = _flags_save_string;
12785                 }
12786                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12787         }
12788         if (ndr_flags & NDR_BUFFERS) {
12789                 {
12790                         uint32_t _flags_save_string = ndr->flags;
12791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12792                         if (r->driver_name) {
12793                                 uint32_t _relative_save_offset;
12794                                 _relative_save_offset = ndr->offset;
12795                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12796                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12797                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12798                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12799                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12800                                 if (ndr->offset > ndr->relative_highest_offset) {
12801                                         ndr->relative_highest_offset = ndr->offset;
12802                                 }
12803                                 ndr->offset = _relative_save_offset;
12804                         }
12805                         ndr->flags = _flags_save_string;
12806                 }
12807                 {
12808                         uint32_t _flags_save_string = ndr->flags;
12809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12810                         if (r->architecture) {
12811                                 uint32_t _relative_save_offset;
12812                                 _relative_save_offset = ndr->offset;
12813                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12814                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12815                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12816                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12817                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12818                                 if (ndr->offset > ndr->relative_highest_offset) {
12819                                         ndr->relative_highest_offset = ndr->offset;
12820                                 }
12821                                 ndr->offset = _relative_save_offset;
12822                         }
12823                         ndr->flags = _flags_save_string;
12824                 }
12825                 {
12826                         uint32_t _flags_save_string = ndr->flags;
12827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12828                         if (r->driver_path) {
12829                                 uint32_t _relative_save_offset;
12830                                 _relative_save_offset = ndr->offset;
12831                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12832                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12833                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12834                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12835                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12836                                 if (ndr->offset > ndr->relative_highest_offset) {
12837                                         ndr->relative_highest_offset = ndr->offset;
12838                                 }
12839                                 ndr->offset = _relative_save_offset;
12840                         }
12841                         ndr->flags = _flags_save_string;
12842                 }
12843                 {
12844                         uint32_t _flags_save_string = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         if (r->data_file) {
12847                                 uint32_t _relative_save_offset;
12848                                 _relative_save_offset = ndr->offset;
12849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12850                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12854                                 if (ndr->offset > ndr->relative_highest_offset) {
12855                                         ndr->relative_highest_offset = ndr->offset;
12856                                 }
12857                                 ndr->offset = _relative_save_offset;
12858                         }
12859                         ndr->flags = _flags_save_string;
12860                 }
12861                 {
12862                         uint32_t _flags_save_string = ndr->flags;
12863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12864                         if (r->config_file) {
12865                                 uint32_t _relative_save_offset;
12866                                 _relative_save_offset = ndr->offset;
12867                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12868                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12869                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12870                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12871                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12872                                 if (ndr->offset > ndr->relative_highest_offset) {
12873                                         ndr->relative_highest_offset = ndr->offset;
12874                                 }
12875                                 ndr->offset = _relative_save_offset;
12876                         }
12877                         ndr->flags = _flags_save_string;
12878                 }
12879                 {
12880                         uint32_t _flags_save_string = ndr->flags;
12881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12882                         if (r->help_file) {
12883                                 uint32_t _relative_save_offset;
12884                                 _relative_save_offset = ndr->offset;
12885                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12886                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12887                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12888                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12889                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12890                                 if (ndr->offset > ndr->relative_highest_offset) {
12891                                         ndr->relative_highest_offset = ndr->offset;
12892                                 }
12893                                 ndr->offset = _relative_save_offset;
12894                         }
12895                         ndr->flags = _flags_save_string;
12896                 }
12897                 {
12898                         uint32_t _flags_save_string_array = ndr->flags;
12899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12900                         if (r->dependent_files) {
12901                                 uint32_t _relative_save_offset;
12902                                 _relative_save_offset = ndr->offset;
12903                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12904                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12905                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12906                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12907                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12908                                 if (ndr->offset > ndr->relative_highest_offset) {
12909                                         ndr->relative_highest_offset = ndr->offset;
12910                                 }
12911                                 ndr->offset = _relative_save_offset;
12912                         }
12913                         ndr->flags = _flags_save_string_array;
12914                 }
12915                 {
12916                         uint32_t _flags_save_string = ndr->flags;
12917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12918                         if (r->monitor_name) {
12919                                 uint32_t _relative_save_offset;
12920                                 _relative_save_offset = ndr->offset;
12921                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12922                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12923                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12924                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12925                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12926                                 if (ndr->offset > ndr->relative_highest_offset) {
12927                                         ndr->relative_highest_offset = ndr->offset;
12928                                 }
12929                                 ndr->offset = _relative_save_offset;
12930                         }
12931                         ndr->flags = _flags_save_string;
12932                 }
12933                 {
12934                         uint32_t _flags_save_string = ndr->flags;
12935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12936                         if (r->default_datatype) {
12937                                 uint32_t _relative_save_offset;
12938                                 _relative_save_offset = ndr->offset;
12939                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12940                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12941                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12942                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12943                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12944                                 if (ndr->offset > ndr->relative_highest_offset) {
12945                                         ndr->relative_highest_offset = ndr->offset;
12946                                 }
12947                                 ndr->offset = _relative_save_offset;
12948                         }
12949                         ndr->flags = _flags_save_string;
12950                 }
12951                 {
12952                         uint32_t _flags_save_string_array = ndr->flags;
12953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12954                         if (r->previous_names) {
12955                                 uint32_t _relative_save_offset;
12956                                 _relative_save_offset = ndr->offset;
12957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12958                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12959                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12960                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12962                                 if (ndr->offset > ndr->relative_highest_offset) {
12963                                         ndr->relative_highest_offset = ndr->offset;
12964                                 }
12965                                 ndr->offset = _relative_save_offset;
12966                         }
12967                         ndr->flags = _flags_save_string_array;
12968                 }
12969                 {
12970                         uint32_t _flags_save_string = ndr->flags;
12971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12972                         if (r->manufacturer_name) {
12973                                 uint32_t _relative_save_offset;
12974                                 _relative_save_offset = ndr->offset;
12975                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12976                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12977                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12978                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12979                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12980                                 if (ndr->offset > ndr->relative_highest_offset) {
12981                                         ndr->relative_highest_offset = ndr->offset;
12982                                 }
12983                                 ndr->offset = _relative_save_offset;
12984                         }
12985                         ndr->flags = _flags_save_string;
12986                 }
12987                 {
12988                         uint32_t _flags_save_string = ndr->flags;
12989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12990                         if (r->manufacturer_url) {
12991                                 uint32_t _relative_save_offset;
12992                                 _relative_save_offset = ndr->offset;
12993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12994                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12995                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12998                                 if (ndr->offset > ndr->relative_highest_offset) {
12999                                         ndr->relative_highest_offset = ndr->offset;
13000                                 }
13001                                 ndr->offset = _relative_save_offset;
13002                         }
13003                         ndr->flags = _flags_save_string;
13004                 }
13005                 {
13006                         uint32_t _flags_save_string = ndr->flags;
13007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13008                         if (r->hardware_id) {
13009                                 uint32_t _relative_save_offset;
13010                                 _relative_save_offset = ndr->offset;
13011                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13012                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13013                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13014                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13015                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13016                                 if (ndr->offset > ndr->relative_highest_offset) {
13017                                         ndr->relative_highest_offset = ndr->offset;
13018                                 }
13019                                 ndr->offset = _relative_save_offset;
13020                         }
13021                         ndr->flags = _flags_save_string;
13022                 }
13023                 {
13024                         uint32_t _flags_save_string = ndr->flags;
13025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13026                         if (r->provider) {
13027                                 uint32_t _relative_save_offset;
13028                                 _relative_save_offset = ndr->offset;
13029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13030                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13031                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13034                                 if (ndr->offset > ndr->relative_highest_offset) {
13035                                         ndr->relative_highest_offset = ndr->offset;
13036                                 }
13037                                 ndr->offset = _relative_save_offset;
13038                         }
13039                         ndr->flags = _flags_save_string;
13040                 }
13041         }
13042         return NDR_ERR_SUCCESS;
13043 }
13044
13045 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13046 {
13047         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13048         ndr->depth++;
13049         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13050         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13051         ndr->depth++;
13052         if (r->driver_name) {
13053                 ndr_print_string(ndr, "driver_name", r->driver_name);
13054         }
13055         ndr->depth--;
13056         ndr_print_ptr(ndr, "architecture", r->architecture);
13057         ndr->depth++;
13058         if (r->architecture) {
13059                 ndr_print_string(ndr, "architecture", r->architecture);
13060         }
13061         ndr->depth--;
13062         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13063         ndr->depth++;
13064         if (r->driver_path) {
13065                 ndr_print_string(ndr, "driver_path", r->driver_path);
13066         }
13067         ndr->depth--;
13068         ndr_print_ptr(ndr, "data_file", r->data_file);
13069         ndr->depth++;
13070         if (r->data_file) {
13071                 ndr_print_string(ndr, "data_file", r->data_file);
13072         }
13073         ndr->depth--;
13074         ndr_print_ptr(ndr, "config_file", r->config_file);
13075         ndr->depth++;
13076         if (r->config_file) {
13077                 ndr_print_string(ndr, "config_file", r->config_file);
13078         }
13079         ndr->depth--;
13080         ndr_print_ptr(ndr, "help_file", r->help_file);
13081         ndr->depth++;
13082         if (r->help_file) {
13083                 ndr_print_string(ndr, "help_file", r->help_file);
13084         }
13085         ndr->depth--;
13086         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13087         ndr->depth++;
13088         if (r->dependent_files) {
13089                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13090         }
13091         ndr->depth--;
13092         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13093         ndr->depth++;
13094         if (r->monitor_name) {
13095                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13096         }
13097         ndr->depth--;
13098         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13099         ndr->depth++;
13100         if (r->default_datatype) {
13101                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13102         }
13103         ndr->depth--;
13104         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13105         ndr->depth++;
13106         if (r->previous_names) {
13107                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13108         }
13109         ndr->depth--;
13110         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13111         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13112         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13113         ndr->depth++;
13114         if (r->manufacturer_name) {
13115                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13116         }
13117         ndr->depth--;
13118         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13119         ndr->depth++;
13120         if (r->manufacturer_url) {
13121                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13122         }
13123         ndr->depth--;
13124         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13125         ndr->depth++;
13126         if (r->hardware_id) {
13127                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13128         }
13129         ndr->depth--;
13130         ndr_print_ptr(ndr, "provider", r->provider);
13131         ndr->depth++;
13132         if (r->provider) {
13133                 ndr_print_string(ndr, "provider", r->provider);
13134         }
13135         ndr->depth--;
13136         ndr->depth--;
13137 }
13138
13139 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13140 {
13141         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13142 }
13143
13144 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13145 {
13146         if (ndr_flags & NDR_SCALARS) {
13147                 NDR_CHECK(ndr_push_align(ndr, 8));
13148                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13149                 {
13150                         uint32_t _flags_save_string = ndr->flags;
13151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13152                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13153                         ndr->flags = _flags_save_string;
13154                 }
13155                 {
13156                         uint32_t _flags_save_string = ndr->flags;
13157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13158                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13159                         ndr->flags = _flags_save_string;
13160                 }
13161                 {
13162                         uint32_t _flags_save_string = ndr->flags;
13163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13164                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13165                         ndr->flags = _flags_save_string;
13166                 }
13167                 {
13168                         uint32_t _flags_save_string = ndr->flags;
13169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13170                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13171                         ndr->flags = _flags_save_string;
13172                 }
13173                 {
13174                         uint32_t _flags_save_string = ndr->flags;
13175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13176                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13177                         ndr->flags = _flags_save_string;
13178                 }
13179                 {
13180                         uint32_t _flags_save_string = ndr->flags;
13181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13182                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13183                         ndr->flags = _flags_save_string;
13184                 }
13185                 {
13186                         uint32_t _flags_save_string = ndr->flags;
13187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13188                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13189                         ndr->flags = _flags_save_string;
13190                 }
13191                 {
13192                         uint32_t _flags_save_string = ndr->flags;
13193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13194                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13195                         ndr->flags = _flags_save_string;
13196                 }
13197                 {
13198                         uint32_t _flags_save_string_array = ndr->flags;
13199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13200                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13201                         ndr->flags = _flags_save_string_array;
13202                 }
13203                 {
13204                         uint32_t _flags_save_string_array = ndr->flags;
13205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13206                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13207                         ndr->flags = _flags_save_string_array;
13208                 }
13209                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13210                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13211                 {
13212                         uint32_t _flags_save_string = ndr->flags;
13213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13214                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13215                         ndr->flags = _flags_save_string;
13216                 }
13217                 {
13218                         uint32_t _flags_save_string = ndr->flags;
13219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13220                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13221                         ndr->flags = _flags_save_string;
13222                 }
13223                 {
13224                         uint32_t _flags_save_string = ndr->flags;
13225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13226                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13227                         ndr->flags = _flags_save_string;
13228                 }
13229                 {
13230                         uint32_t _flags_save_string = ndr->flags;
13231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13232                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13233                         ndr->flags = _flags_save_string;
13234                 }
13235                 {
13236                         uint32_t _flags_save_string = ndr->flags;
13237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13238                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13239                         ndr->flags = _flags_save_string;
13240                 }
13241                 {
13242                         uint32_t _flags_save_string = ndr->flags;
13243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13244                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13245                         ndr->flags = _flags_save_string;
13246                 }
13247                 {
13248                         uint32_t _flags_save_string_array = ndr->flags;
13249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13250                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13251                         ndr->flags = _flags_save_string_array;
13252                 }
13253                 {
13254                         uint32_t _flags_save_string = ndr->flags;
13255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13256                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13257                         ndr->flags = _flags_save_string;
13258                 }
13259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13260                 {
13261                         uint32_t _flags_save_string_array = ndr->flags;
13262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13263                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13264                         ndr->flags = _flags_save_string_array;
13265                 }
13266                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13267                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13268                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13269         }
13270         if (ndr_flags & NDR_BUFFERS) {
13271                 {
13272                         uint32_t _flags_save_string = ndr->flags;
13273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13274                         if (r->driver_name) {
13275                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
13276                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13277                         }
13278                         ndr->flags = _flags_save_string;
13279                 }
13280                 {
13281                         uint32_t _flags_save_string = ndr->flags;
13282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13283                         if (r->architecture) {
13284                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
13285                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13286                         }
13287                         ndr->flags = _flags_save_string;
13288                 }
13289                 {
13290                         uint32_t _flags_save_string = ndr->flags;
13291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13292                         if (r->driver_path) {
13293                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
13294                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13295                         }
13296                         ndr->flags = _flags_save_string;
13297                 }
13298                 {
13299                         uint32_t _flags_save_string = ndr->flags;
13300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13301                         if (r->data_file) {
13302                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
13303                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13304                         }
13305                         ndr->flags = _flags_save_string;
13306                 }
13307                 {
13308                         uint32_t _flags_save_string = ndr->flags;
13309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13310                         if (r->config_file) {
13311                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
13312                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13313                         }
13314                         ndr->flags = _flags_save_string;
13315                 }
13316                 {
13317                         uint32_t _flags_save_string = ndr->flags;
13318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13319                         if (r->help_file) {
13320                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
13321                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13322                         }
13323                         ndr->flags = _flags_save_string;
13324                 }
13325                 {
13326                         uint32_t _flags_save_string = ndr->flags;
13327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13328                         if (r->monitor_name) {
13329                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13330                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13331                         }
13332                         ndr->flags = _flags_save_string;
13333                 }
13334                 {
13335                         uint32_t _flags_save_string = ndr->flags;
13336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13337                         if (r->default_datatype) {
13338                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
13339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13340                         }
13341                         ndr->flags = _flags_save_string;
13342                 }
13343                 {
13344                         uint32_t _flags_save_string_array = ndr->flags;
13345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13346                         if (r->dependent_files) {
13347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
13348                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13349                         }
13350                         ndr->flags = _flags_save_string_array;
13351                 }
13352                 {
13353                         uint32_t _flags_save_string_array = ndr->flags;
13354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13355                         if (r->previous_names) {
13356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
13357                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13358                         }
13359                         ndr->flags = _flags_save_string_array;
13360                 }
13361                 {
13362                         uint32_t _flags_save_string = ndr->flags;
13363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13364                         if (r->manufacturer_name) {
13365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
13366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13367                         }
13368                         ndr->flags = _flags_save_string;
13369                 }
13370                 {
13371                         uint32_t _flags_save_string = ndr->flags;
13372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13373                         if (r->manufacturer_url) {
13374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
13375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13376                         }
13377                         ndr->flags = _flags_save_string;
13378                 }
13379                 {
13380                         uint32_t _flags_save_string = ndr->flags;
13381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13382                         if (r->hardware_id) {
13383                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
13384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13385                         }
13386                         ndr->flags = _flags_save_string;
13387                 }
13388                 {
13389                         uint32_t _flags_save_string = ndr->flags;
13390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13391                         if (r->provider) {
13392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
13393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13394                         }
13395                         ndr->flags = _flags_save_string;
13396                 }
13397                 {
13398                         uint32_t _flags_save_string = ndr->flags;
13399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13400                         if (r->print_processor) {
13401                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13403                         }
13404                         ndr->flags = _flags_save_string;
13405                 }
13406                 {
13407                         uint32_t _flags_save_string = ndr->flags;
13408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13409                         if (r->vendor_setup) {
13410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13412                         }
13413                         ndr->flags = _flags_save_string;
13414                 }
13415                 {
13416                         uint32_t _flags_save_string_array = ndr->flags;
13417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13418                         if (r->color_profiles) {
13419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13420                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13421                         }
13422                         ndr->flags = _flags_save_string_array;
13423                 }
13424                 {
13425                         uint32_t _flags_save_string = ndr->flags;
13426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13427                         if (r->inf_path) {
13428                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13430                         }
13431                         ndr->flags = _flags_save_string;
13432                 }
13433                 {
13434                         uint32_t _flags_save_string_array = ndr->flags;
13435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13436                         if (r->core_driver_dependencies) {
13437                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13438                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13439                         }
13440                         ndr->flags = _flags_save_string_array;
13441                 }
13442         }
13443         return NDR_ERR_SUCCESS;
13444 }
13445
13446 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13447 {
13448         uint32_t _ptr_driver_name;
13449         TALLOC_CTX *_mem_save_driver_name_0;
13450         uint32_t _ptr_architecture;
13451         TALLOC_CTX *_mem_save_architecture_0;
13452         uint32_t _ptr_driver_path;
13453         TALLOC_CTX *_mem_save_driver_path_0;
13454         uint32_t _ptr_data_file;
13455         TALLOC_CTX *_mem_save_data_file_0;
13456         uint32_t _ptr_config_file;
13457         TALLOC_CTX *_mem_save_config_file_0;
13458         uint32_t _ptr_help_file;
13459         TALLOC_CTX *_mem_save_help_file_0;
13460         uint32_t _ptr_monitor_name;
13461         TALLOC_CTX *_mem_save_monitor_name_0;
13462         uint32_t _ptr_default_datatype;
13463         TALLOC_CTX *_mem_save_default_datatype_0;
13464         uint32_t _ptr_dependent_files;
13465         TALLOC_CTX *_mem_save_dependent_files_0;
13466         uint32_t _ptr_previous_names;
13467         TALLOC_CTX *_mem_save_previous_names_0;
13468         uint32_t _ptr_manufacturer_name;
13469         TALLOC_CTX *_mem_save_manufacturer_name_0;
13470         uint32_t _ptr_manufacturer_url;
13471         TALLOC_CTX *_mem_save_manufacturer_url_0;
13472         uint32_t _ptr_hardware_id;
13473         TALLOC_CTX *_mem_save_hardware_id_0;
13474         uint32_t _ptr_provider;
13475         TALLOC_CTX *_mem_save_provider_0;
13476         uint32_t _ptr_print_processor;
13477         TALLOC_CTX *_mem_save_print_processor_0;
13478         uint32_t _ptr_vendor_setup;
13479         TALLOC_CTX *_mem_save_vendor_setup_0;
13480         uint32_t _ptr_color_profiles;
13481         TALLOC_CTX *_mem_save_color_profiles_0;
13482         uint32_t _ptr_inf_path;
13483         TALLOC_CTX *_mem_save_inf_path_0;
13484         uint32_t _ptr_core_driver_dependencies;
13485         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13486         if (ndr_flags & NDR_SCALARS) {
13487                 NDR_CHECK(ndr_pull_align(ndr, 8));
13488                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13489                 {
13490                         uint32_t _flags_save_string = ndr->flags;
13491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13492                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13493                         if (_ptr_driver_name) {
13494                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13495                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13496                         } else {
13497                                 r->driver_name = NULL;
13498                         }
13499                         ndr->flags = _flags_save_string;
13500                 }
13501                 {
13502                         uint32_t _flags_save_string = ndr->flags;
13503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13504                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13505                         if (_ptr_architecture) {
13506                                 NDR_PULL_ALLOC(ndr, r->architecture);
13507                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13508                         } else {
13509                                 r->architecture = NULL;
13510                         }
13511                         ndr->flags = _flags_save_string;
13512                 }
13513                 {
13514                         uint32_t _flags_save_string = ndr->flags;
13515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13516                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13517                         if (_ptr_driver_path) {
13518                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13519                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13520                         } else {
13521                                 r->driver_path = NULL;
13522                         }
13523                         ndr->flags = _flags_save_string;
13524                 }
13525                 {
13526                         uint32_t _flags_save_string = ndr->flags;
13527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13528                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13529                         if (_ptr_data_file) {
13530                                 NDR_PULL_ALLOC(ndr, r->data_file);
13531                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13532                         } else {
13533                                 r->data_file = NULL;
13534                         }
13535                         ndr->flags = _flags_save_string;
13536                 }
13537                 {
13538                         uint32_t _flags_save_string = ndr->flags;
13539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13540                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13541                         if (_ptr_config_file) {
13542                                 NDR_PULL_ALLOC(ndr, r->config_file);
13543                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13544                         } else {
13545                                 r->config_file = NULL;
13546                         }
13547                         ndr->flags = _flags_save_string;
13548                 }
13549                 {
13550                         uint32_t _flags_save_string = ndr->flags;
13551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13552                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13553                         if (_ptr_help_file) {
13554                                 NDR_PULL_ALLOC(ndr, r->help_file);
13555                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13556                         } else {
13557                                 r->help_file = NULL;
13558                         }
13559                         ndr->flags = _flags_save_string;
13560                 }
13561                 {
13562                         uint32_t _flags_save_string = ndr->flags;
13563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13564                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13565                         if (_ptr_monitor_name) {
13566                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13567                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13568                         } else {
13569                                 r->monitor_name = NULL;
13570                         }
13571                         ndr->flags = _flags_save_string;
13572                 }
13573                 {
13574                         uint32_t _flags_save_string = ndr->flags;
13575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13576                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13577                         if (_ptr_default_datatype) {
13578                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13579                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13580                         } else {
13581                                 r->default_datatype = NULL;
13582                         }
13583                         ndr->flags = _flags_save_string;
13584                 }
13585                 {
13586                         uint32_t _flags_save_string_array = ndr->flags;
13587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13588                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13589                         if (_ptr_dependent_files) {
13590                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13591                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13592                         } else {
13593                                 r->dependent_files = NULL;
13594                         }
13595                         ndr->flags = _flags_save_string_array;
13596                 }
13597                 {
13598                         uint32_t _flags_save_string_array = ndr->flags;
13599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13600                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13601                         if (_ptr_previous_names) {
13602                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13603                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13604                         } else {
13605                                 r->previous_names = NULL;
13606                         }
13607                         ndr->flags = _flags_save_string_array;
13608                 }
13609                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13610                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13611                 {
13612                         uint32_t _flags_save_string = ndr->flags;
13613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13614                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13615                         if (_ptr_manufacturer_name) {
13616                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13617                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13618                         } else {
13619                                 r->manufacturer_name = NULL;
13620                         }
13621                         ndr->flags = _flags_save_string;
13622                 }
13623                 {
13624                         uint32_t _flags_save_string = ndr->flags;
13625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13626                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13627                         if (_ptr_manufacturer_url) {
13628                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13629                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13630                         } else {
13631                                 r->manufacturer_url = NULL;
13632                         }
13633                         ndr->flags = _flags_save_string;
13634                 }
13635                 {
13636                         uint32_t _flags_save_string = ndr->flags;
13637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13638                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13639                         if (_ptr_hardware_id) {
13640                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13641                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13642                         } else {
13643                                 r->hardware_id = NULL;
13644                         }
13645                         ndr->flags = _flags_save_string;
13646                 }
13647                 {
13648                         uint32_t _flags_save_string = ndr->flags;
13649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13651                         if (_ptr_provider) {
13652                                 NDR_PULL_ALLOC(ndr, r->provider);
13653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13654                         } else {
13655                                 r->provider = NULL;
13656                         }
13657                         ndr->flags = _flags_save_string;
13658                 }
13659                 {
13660                         uint32_t _flags_save_string = ndr->flags;
13661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13663                         if (_ptr_print_processor) {
13664                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13666                         } else {
13667                                 r->print_processor = NULL;
13668                         }
13669                         ndr->flags = _flags_save_string;
13670                 }
13671                 {
13672                         uint32_t _flags_save_string = ndr->flags;
13673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13675                         if (_ptr_vendor_setup) {
13676                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13678                         } else {
13679                                 r->vendor_setup = NULL;
13680                         }
13681                         ndr->flags = _flags_save_string;
13682                 }
13683                 {
13684                         uint32_t _flags_save_string_array = ndr->flags;
13685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13687                         if (_ptr_color_profiles) {
13688                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13690                         } else {
13691                                 r->color_profiles = NULL;
13692                         }
13693                         ndr->flags = _flags_save_string_array;
13694                 }
13695                 {
13696                         uint32_t _flags_save_string = ndr->flags;
13697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13699                         if (_ptr_inf_path) {
13700                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13702                         } else {
13703                                 r->inf_path = NULL;
13704                         }
13705                         ndr->flags = _flags_save_string;
13706                 }
13707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13708                 {
13709                         uint32_t _flags_save_string_array = ndr->flags;
13710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13712                         if (_ptr_core_driver_dependencies) {
13713                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13715                         } else {
13716                                 r->core_driver_dependencies = NULL;
13717                         }
13718                         ndr->flags = _flags_save_string_array;
13719                 }
13720                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13721                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13722                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13723         }
13724         if (ndr_flags & NDR_BUFFERS) {
13725                 {
13726                         uint32_t _flags_save_string = ndr->flags;
13727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13728                         if (r->driver_name) {
13729                                 uint32_t _relative_save_offset;
13730                                 _relative_save_offset = ndr->offset;
13731                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13732                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13733                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13734                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13735                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13736                                 if (ndr->offset > ndr->relative_highest_offset) {
13737                                         ndr->relative_highest_offset = ndr->offset;
13738                                 }
13739                                 ndr->offset = _relative_save_offset;
13740                         }
13741                         ndr->flags = _flags_save_string;
13742                 }
13743                 {
13744                         uint32_t _flags_save_string = ndr->flags;
13745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13746                         if (r->architecture) {
13747                                 uint32_t _relative_save_offset;
13748                                 _relative_save_offset = ndr->offset;
13749                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13750                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13751                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13752                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13753                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13754                                 if (ndr->offset > ndr->relative_highest_offset) {
13755                                         ndr->relative_highest_offset = ndr->offset;
13756                                 }
13757                                 ndr->offset = _relative_save_offset;
13758                         }
13759                         ndr->flags = _flags_save_string;
13760                 }
13761                 {
13762                         uint32_t _flags_save_string = ndr->flags;
13763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13764                         if (r->driver_path) {
13765                                 uint32_t _relative_save_offset;
13766                                 _relative_save_offset = ndr->offset;
13767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13768                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13769                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13772                                 if (ndr->offset > ndr->relative_highest_offset) {
13773                                         ndr->relative_highest_offset = ndr->offset;
13774                                 }
13775                                 ndr->offset = _relative_save_offset;
13776                         }
13777                         ndr->flags = _flags_save_string;
13778                 }
13779                 {
13780                         uint32_t _flags_save_string = ndr->flags;
13781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13782                         if (r->data_file) {
13783                                 uint32_t _relative_save_offset;
13784                                 _relative_save_offset = ndr->offset;
13785                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13786                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13787                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13788                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13789                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13790                                 if (ndr->offset > ndr->relative_highest_offset) {
13791                                         ndr->relative_highest_offset = ndr->offset;
13792                                 }
13793                                 ndr->offset = _relative_save_offset;
13794                         }
13795                         ndr->flags = _flags_save_string;
13796                 }
13797                 {
13798                         uint32_t _flags_save_string = ndr->flags;
13799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13800                         if (r->config_file) {
13801                                 uint32_t _relative_save_offset;
13802                                 _relative_save_offset = ndr->offset;
13803                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13804                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13805                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13806                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13807                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13808                                 if (ndr->offset > ndr->relative_highest_offset) {
13809                                         ndr->relative_highest_offset = ndr->offset;
13810                                 }
13811                                 ndr->offset = _relative_save_offset;
13812                         }
13813                         ndr->flags = _flags_save_string;
13814                 }
13815                 {
13816                         uint32_t _flags_save_string = ndr->flags;
13817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13818                         if (r->help_file) {
13819                                 uint32_t _relative_save_offset;
13820                                 _relative_save_offset = ndr->offset;
13821                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13822                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13823                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13824                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13825                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13826                                 if (ndr->offset > ndr->relative_highest_offset) {
13827                                         ndr->relative_highest_offset = ndr->offset;
13828                                 }
13829                                 ndr->offset = _relative_save_offset;
13830                         }
13831                         ndr->flags = _flags_save_string;
13832                 }
13833                 {
13834                         uint32_t _flags_save_string = ndr->flags;
13835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13836                         if (r->monitor_name) {
13837                                 uint32_t _relative_save_offset;
13838                                 _relative_save_offset = ndr->offset;
13839                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13840                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13841                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13842                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13843                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13844                                 if (ndr->offset > ndr->relative_highest_offset) {
13845                                         ndr->relative_highest_offset = ndr->offset;
13846                                 }
13847                                 ndr->offset = _relative_save_offset;
13848                         }
13849                         ndr->flags = _flags_save_string;
13850                 }
13851                 {
13852                         uint32_t _flags_save_string = ndr->flags;
13853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13854                         if (r->default_datatype) {
13855                                 uint32_t _relative_save_offset;
13856                                 _relative_save_offset = ndr->offset;
13857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13858                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13859                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13862                                 if (ndr->offset > ndr->relative_highest_offset) {
13863                                         ndr->relative_highest_offset = ndr->offset;
13864                                 }
13865                                 ndr->offset = _relative_save_offset;
13866                         }
13867                         ndr->flags = _flags_save_string;
13868                 }
13869                 {
13870                         uint32_t _flags_save_string_array = ndr->flags;
13871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13872                         if (r->dependent_files) {
13873                                 uint32_t _relative_save_offset;
13874                                 _relative_save_offset = ndr->offset;
13875                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13876                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13877                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13878                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13879                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13880                                 if (ndr->offset > ndr->relative_highest_offset) {
13881                                         ndr->relative_highest_offset = ndr->offset;
13882                                 }
13883                                 ndr->offset = _relative_save_offset;
13884                         }
13885                         ndr->flags = _flags_save_string_array;
13886                 }
13887                 {
13888                         uint32_t _flags_save_string_array = ndr->flags;
13889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13890                         if (r->previous_names) {
13891                                 uint32_t _relative_save_offset;
13892                                 _relative_save_offset = ndr->offset;
13893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13894                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13895                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13896                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13898                                 if (ndr->offset > ndr->relative_highest_offset) {
13899                                         ndr->relative_highest_offset = ndr->offset;
13900                                 }
13901                                 ndr->offset = _relative_save_offset;
13902                         }
13903                         ndr->flags = _flags_save_string_array;
13904                 }
13905                 {
13906                         uint32_t _flags_save_string = ndr->flags;
13907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13908                         if (r->manufacturer_name) {
13909                                 uint32_t _relative_save_offset;
13910                                 _relative_save_offset = ndr->offset;
13911                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13912                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13913                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13914                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13915                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13916                                 if (ndr->offset > ndr->relative_highest_offset) {
13917                                         ndr->relative_highest_offset = ndr->offset;
13918                                 }
13919                                 ndr->offset = _relative_save_offset;
13920                         }
13921                         ndr->flags = _flags_save_string;
13922                 }
13923                 {
13924                         uint32_t _flags_save_string = ndr->flags;
13925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13926                         if (r->manufacturer_url) {
13927                                 uint32_t _relative_save_offset;
13928                                 _relative_save_offset = ndr->offset;
13929                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13930                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13931                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13932                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13933                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13934                                 if (ndr->offset > ndr->relative_highest_offset) {
13935                                         ndr->relative_highest_offset = ndr->offset;
13936                                 }
13937                                 ndr->offset = _relative_save_offset;
13938                         }
13939                         ndr->flags = _flags_save_string;
13940                 }
13941                 {
13942                         uint32_t _flags_save_string = ndr->flags;
13943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13944                         if (r->hardware_id) {
13945                                 uint32_t _relative_save_offset;
13946                                 _relative_save_offset = ndr->offset;
13947                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13948                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13949                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13950                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13951                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13952                                 if (ndr->offset > ndr->relative_highest_offset) {
13953                                         ndr->relative_highest_offset = ndr->offset;
13954                                 }
13955                                 ndr->offset = _relative_save_offset;
13956                         }
13957                         ndr->flags = _flags_save_string;
13958                 }
13959                 {
13960                         uint32_t _flags_save_string = ndr->flags;
13961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13962                         if (r->provider) {
13963                                 uint32_t _relative_save_offset;
13964                                 _relative_save_offset = ndr->offset;
13965                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13966                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13967                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13968                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13969                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13970                                 if (ndr->offset > ndr->relative_highest_offset) {
13971                                         ndr->relative_highest_offset = ndr->offset;
13972                                 }
13973                                 ndr->offset = _relative_save_offset;
13974                         }
13975                         ndr->flags = _flags_save_string;
13976                 }
13977                 {
13978                         uint32_t _flags_save_string = ndr->flags;
13979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13980                         if (r->print_processor) {
13981                                 uint32_t _relative_save_offset;
13982                                 _relative_save_offset = ndr->offset;
13983                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13984                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13985                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13986                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13987                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13988                                 if (ndr->offset > ndr->relative_highest_offset) {
13989                                         ndr->relative_highest_offset = ndr->offset;
13990                                 }
13991                                 ndr->offset = _relative_save_offset;
13992                         }
13993                         ndr->flags = _flags_save_string;
13994                 }
13995                 {
13996                         uint32_t _flags_save_string = ndr->flags;
13997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13998                         if (r->vendor_setup) {
13999                                 uint32_t _relative_save_offset;
14000                                 _relative_save_offset = ndr->offset;
14001                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14002                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14003                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14004                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14005                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14006                                 if (ndr->offset > ndr->relative_highest_offset) {
14007                                         ndr->relative_highest_offset = ndr->offset;
14008                                 }
14009                                 ndr->offset = _relative_save_offset;
14010                         }
14011                         ndr->flags = _flags_save_string;
14012                 }
14013                 {
14014                         uint32_t _flags_save_string_array = ndr->flags;
14015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14016                         if (r->color_profiles) {
14017                                 uint32_t _relative_save_offset;
14018                                 _relative_save_offset = ndr->offset;
14019                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14020                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14021                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14022                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14023                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14024                                 if (ndr->offset > ndr->relative_highest_offset) {
14025                                         ndr->relative_highest_offset = ndr->offset;
14026                                 }
14027                                 ndr->offset = _relative_save_offset;
14028                         }
14029                         ndr->flags = _flags_save_string_array;
14030                 }
14031                 {
14032                         uint32_t _flags_save_string = ndr->flags;
14033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14034                         if (r->inf_path) {
14035                                 uint32_t _relative_save_offset;
14036                                 _relative_save_offset = ndr->offset;
14037                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14038                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14039                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14040                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14041                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14042                                 if (ndr->offset > ndr->relative_highest_offset) {
14043                                         ndr->relative_highest_offset = ndr->offset;
14044                                 }
14045                                 ndr->offset = _relative_save_offset;
14046                         }
14047                         ndr->flags = _flags_save_string;
14048                 }
14049                 {
14050                         uint32_t _flags_save_string_array = ndr->flags;
14051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14052                         if (r->core_driver_dependencies) {
14053                                 uint32_t _relative_save_offset;
14054                                 _relative_save_offset = ndr->offset;
14055                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14056                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14057                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14058                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14059                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14060                                 if (ndr->offset > ndr->relative_highest_offset) {
14061                                         ndr->relative_highest_offset = ndr->offset;
14062                                 }
14063                                 ndr->offset = _relative_save_offset;
14064                         }
14065                         ndr->flags = _flags_save_string_array;
14066                 }
14067         }
14068         return NDR_ERR_SUCCESS;
14069 }
14070
14071 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14072 {
14073         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14074         ndr->depth++;
14075         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14076         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14077         ndr->depth++;
14078         if (r->driver_name) {
14079                 ndr_print_string(ndr, "driver_name", r->driver_name);
14080         }
14081         ndr->depth--;
14082         ndr_print_ptr(ndr, "architecture", r->architecture);
14083         ndr->depth++;
14084         if (r->architecture) {
14085                 ndr_print_string(ndr, "architecture", r->architecture);
14086         }
14087         ndr->depth--;
14088         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14089         ndr->depth++;
14090         if (r->driver_path) {
14091                 ndr_print_string(ndr, "driver_path", r->driver_path);
14092         }
14093         ndr->depth--;
14094         ndr_print_ptr(ndr, "data_file", r->data_file);
14095         ndr->depth++;
14096         if (r->data_file) {
14097                 ndr_print_string(ndr, "data_file", r->data_file);
14098         }
14099         ndr->depth--;
14100         ndr_print_ptr(ndr, "config_file", r->config_file);
14101         ndr->depth++;
14102         if (r->config_file) {
14103                 ndr_print_string(ndr, "config_file", r->config_file);
14104         }
14105         ndr->depth--;
14106         ndr_print_ptr(ndr, "help_file", r->help_file);
14107         ndr->depth++;
14108         if (r->help_file) {
14109                 ndr_print_string(ndr, "help_file", r->help_file);
14110         }
14111         ndr->depth--;
14112         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14113         ndr->depth++;
14114         if (r->monitor_name) {
14115                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14116         }
14117         ndr->depth--;
14118         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14119         ndr->depth++;
14120         if (r->default_datatype) {
14121                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14122         }
14123         ndr->depth--;
14124         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14125         ndr->depth++;
14126         if (r->dependent_files) {
14127                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14128         }
14129         ndr->depth--;
14130         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14131         ndr->depth++;
14132         if (r->previous_names) {
14133                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14134         }
14135         ndr->depth--;
14136         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14137         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14138         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14139         ndr->depth++;
14140         if (r->manufacturer_name) {
14141                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14142         }
14143         ndr->depth--;
14144         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14145         ndr->depth++;
14146         if (r->manufacturer_url) {
14147                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14148         }
14149         ndr->depth--;
14150         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14151         ndr->depth++;
14152         if (r->hardware_id) {
14153                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14154         }
14155         ndr->depth--;
14156         ndr_print_ptr(ndr, "provider", r->provider);
14157         ndr->depth++;
14158         if (r->provider) {
14159                 ndr_print_string(ndr, "provider", r->provider);
14160         }
14161         ndr->depth--;
14162         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14163         ndr->depth++;
14164         if (r->print_processor) {
14165                 ndr_print_string(ndr, "print_processor", r->print_processor);
14166         }
14167         ndr->depth--;
14168         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14169         ndr->depth++;
14170         if (r->vendor_setup) {
14171                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14172         }
14173         ndr->depth--;
14174         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14175         ndr->depth++;
14176         if (r->color_profiles) {
14177                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14178         }
14179         ndr->depth--;
14180         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14181         ndr->depth++;
14182         if (r->inf_path) {
14183                 ndr_print_string(ndr, "inf_path", r->inf_path);
14184         }
14185         ndr->depth--;
14186         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14187         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14188         ndr->depth++;
14189         if (r->core_driver_dependencies) {
14190                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14191         }
14192         ndr->depth--;
14193         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14194         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14195         ndr->depth--;
14196 }
14197
14198 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14199 {
14200         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14201 }
14202
14203 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14204 {
14205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14206         return NDR_ERR_SUCCESS;
14207 }
14208
14209 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14210 {
14211         uint32_t v;
14212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14213         *r = v;
14214         return NDR_ERR_SUCCESS;
14215 }
14216
14217 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14218 {
14219         const char *val = NULL;
14220
14221         switch (r) {
14222                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14223                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14224                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14225                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14226                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14227         }
14228         ndr_print_enum(ndr, name, "ENUM", val, r);
14229 }
14230
14231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14232 {
14233         if (ndr_flags & NDR_SCALARS) {
14234                 NDR_CHECK(ndr_push_align(ndr, 5));
14235                 {
14236                         uint32_t _flags_save_string = ndr->flags;
14237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14238                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14239                         ndr->flags = _flags_save_string;
14240                 }
14241                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14243                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14244         }
14245         if (ndr_flags & NDR_BUFFERS) {
14246                 {
14247                         uint32_t _flags_save_string = ndr->flags;
14248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14249                         if (r->file_name) {
14250                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
14251                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14252                         }
14253                         ndr->flags = _flags_save_string;
14254                 }
14255         }
14256         return NDR_ERR_SUCCESS;
14257 }
14258
14259 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14260 {
14261         uint32_t _ptr_file_name;
14262         TALLOC_CTX *_mem_save_file_name_0;
14263         if (ndr_flags & NDR_SCALARS) {
14264                 NDR_CHECK(ndr_pull_align(ndr, 5));
14265                 {
14266                         uint32_t _flags_save_string = ndr->flags;
14267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14268                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14269                         if (_ptr_file_name) {
14270                                 NDR_PULL_ALLOC(ndr, r->file_name);
14271                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14272                         } else {
14273                                 r->file_name = NULL;
14274                         }
14275                         ndr->flags = _flags_save_string;
14276                 }
14277                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14279                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14280         }
14281         if (ndr_flags & NDR_BUFFERS) {
14282                 {
14283                         uint32_t _flags_save_string = ndr->flags;
14284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14285                         if (r->file_name) {
14286                                 uint32_t _relative_save_offset;
14287                                 _relative_save_offset = ndr->offset;
14288                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14289                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14290                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14291                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14292                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14293                                 if (ndr->offset > ndr->relative_highest_offset) {
14294                                         ndr->relative_highest_offset = ndr->offset;
14295                                 }
14296                                 ndr->offset = _relative_save_offset;
14297                         }
14298                         ndr->flags = _flags_save_string;
14299                 }
14300         }
14301         return NDR_ERR_SUCCESS;
14302 }
14303
14304 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14305 {
14306         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14307         ndr->depth++;
14308         ndr_print_ptr(ndr, "file_name", r->file_name);
14309         ndr->depth++;
14310         if (r->file_name) {
14311                 ndr_print_string(ndr, "file_name", r->file_name);
14312         }
14313         ndr->depth--;
14314         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14315         ndr_print_uint32(ndr, "file_version", r->file_version);
14316         ndr->depth--;
14317 }
14318
14319 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14320 {
14321         uint32_t cntr_file_info_1;
14322         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14323         ndr->depth++;
14324         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14325         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14326         ndr->depth++;
14327         if (r->driver_name) {
14328                 ndr_print_string(ndr, "driver_name", r->driver_name);
14329         }
14330         ndr->depth--;
14331         ndr_print_ptr(ndr, "architecture", r->architecture);
14332         ndr->depth++;
14333         if (r->architecture) {
14334                 ndr_print_string(ndr, "architecture", r->architecture);
14335         }
14336         ndr->depth--;
14337         ndr_print_ptr(ndr, "file_info", r->file_info);
14338         ndr->depth++;
14339         if (r->file_info) {
14340                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14341                 ndr->depth++;
14342                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14343                         char *idx_1=NULL;
14344                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14345                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14346                                 free(idx_1);
14347                         }
14348                 }
14349                 ndr->depth--;
14350         }
14351         ndr->depth--;
14352         ndr_print_uint32(ndr, "file_count", r->file_count);
14353         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14354         ndr->depth++;
14355         if (r->monitor_name) {
14356                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14357         }
14358         ndr->depth--;
14359         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14360         ndr->depth++;
14361         if (r->default_datatype) {
14362                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14363         }
14364         ndr->depth--;
14365         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14366         ndr->depth++;
14367         if (r->previous_names) {
14368                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14369         }
14370         ndr->depth--;
14371         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14372         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14373         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14374         ndr->depth++;
14375         if (r->manufacturer_name) {
14376                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14377         }
14378         ndr->depth--;
14379         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14380         ndr->depth++;
14381         if (r->manufacturer_url) {
14382                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14383         }
14384         ndr->depth--;
14385         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14386         ndr->depth++;
14387         if (r->hardware_id) {
14388                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14389         }
14390         ndr->depth--;
14391         ndr_print_ptr(ndr, "provider", r->provider);
14392         ndr->depth++;
14393         if (r->provider) {
14394                 ndr_print_string(ndr, "provider", r->provider);
14395         }
14396         ndr->depth--;
14397         ndr->depth--;
14398 }
14399
14400 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14401 {
14402         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14403 }
14404
14405 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14406 {
14407         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14408         if (ndr_flags & NDR_SCALARS) {
14409                 int level = ndr_push_get_switch_value(ndr, r);
14410                 NDR_CHECK(ndr_push_union_align(ndr, 8));
14411                 switch (level) {
14412                         case 1: {
14413                                 NDR_CHECK(ndr_push_align(ndr, 5));
14414                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14415                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14416                         break; }
14417
14418                         case 2: {
14419                                 NDR_CHECK(ndr_push_align(ndr, 5));
14420                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14421                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14422                         break; }
14423
14424                         case 3: {
14425                                 NDR_CHECK(ndr_push_align(ndr, 5));
14426                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14427                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14428                         break; }
14429
14430                         case 4: {
14431                                 NDR_CHECK(ndr_push_align(ndr, 5));
14432                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14433                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14434                         break; }
14435
14436                         case 5: {
14437                                 NDR_CHECK(ndr_push_align(ndr, 5));
14438                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14439                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14440                         break; }
14441
14442                         case 6: {
14443                                 NDR_CHECK(ndr_push_align(ndr, 8));
14444                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14445                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14446                         break; }
14447
14448                         case 8: {
14449                                 NDR_CHECK(ndr_push_align(ndr, 8));
14450                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14451                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14452                         break; }
14453
14454                         case 101: {
14455                                 NDR_CHECK(ndr_push_align(ndr, 8));
14456                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14457                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14458                         break; }
14459
14460                         default: {
14461                         break; }
14462
14463                 }
14464         }
14465         if (ndr_flags & NDR_BUFFERS) {
14466                 int level = ndr_push_get_switch_value(ndr, r);
14467                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14468                 switch (level) {
14469                         case 1:
14470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14471                         break;
14472
14473                         case 2:
14474                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14475                         break;
14476
14477                         case 3:
14478                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14479                         break;
14480
14481                         case 4:
14482                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14483                         break;
14484
14485                         case 5:
14486                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14487                         break;
14488
14489                         case 6:
14490                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14491                         break;
14492
14493                         case 8:
14494                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14495                         break;
14496
14497                         case 101:
14498                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14499                         break;
14500
14501                         default:
14502                         break;
14503
14504                 }
14505         }
14506         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14507         return NDR_ERR_SUCCESS;
14508 }
14509
14510 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14511 {
14512         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14513         int level;
14514         level = ndr_pull_get_switch_value(ndr, r);
14515         if (ndr_flags & NDR_SCALARS) {
14516                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14517                 switch (level) {
14518                         case 1: {
14519                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14520                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14521                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14522                         break; }
14523
14524                         case 2: {
14525                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14526                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14527                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14528                         break; }
14529
14530                         case 3: {
14531                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14532                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14533                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14534                         break; }
14535
14536                         case 4: {
14537                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14538                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14539                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14540                         break; }
14541
14542                         case 5: {
14543                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14544                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14545                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14546                         break; }
14547
14548                         case 6: {
14549                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14550                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14551                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14552                         break; }
14553
14554                         case 8: {
14555                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14556                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14557                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14558                         break; }
14559
14560                         case 101: {
14561                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14562                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14563                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14564                         break; }
14565
14566                         default: {
14567                         break; }
14568
14569                 }
14570         }
14571         if (ndr_flags & NDR_BUFFERS) {
14572                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14573                 switch (level) {
14574                         case 1:
14575                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14576                         break;
14577
14578                         case 2:
14579                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14580                         break;
14581
14582                         case 3:
14583                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14584                         break;
14585
14586                         case 4:
14587                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14588                         break;
14589
14590                         case 5:
14591                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14592                         break;
14593
14594                         case 6:
14595                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14596                         break;
14597
14598                         case 8:
14599                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14600                         break;
14601
14602                         case 101:
14603                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14604                         break;
14605
14606                         default:
14607                         break;
14608
14609                 }
14610         }
14611         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14612         return NDR_ERR_SUCCESS;
14613 }
14614
14615 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14616 {
14617         int level;
14618         level = ndr_print_get_switch_value(ndr, r);
14619         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14620         switch (level) {
14621                 case 1:
14622                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14623                 break;
14624
14625                 case 2:
14626                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14627                 break;
14628
14629                 case 3:
14630                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14631                 break;
14632
14633                 case 4:
14634                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14635                 break;
14636
14637                 case 5:
14638                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14639                 break;
14640
14641                 case 6:
14642                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14643                 break;
14644
14645                 case 8:
14646                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14647                 break;
14648
14649                 case 101:
14650                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14651                 break;
14652
14653                 default:
14654                 break;
14655
14656         }
14657 }
14658
14659 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14660 {
14661         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14662 }
14663
14664 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14665 {
14666         if (ndr_flags & NDR_SCALARS) {
14667                 NDR_CHECK(ndr_push_align(ndr, 4));
14668                 {
14669                         uint32_t _flags_save_string = ndr->flags;
14670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14671                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14672                         ndr->flags = _flags_save_string;
14673                 }
14674                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14675         }
14676         if (ndr_flags & NDR_BUFFERS) {
14677         }
14678         return NDR_ERR_SUCCESS;
14679 }
14680
14681 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14682 {
14683         if (ndr_flags & NDR_SCALARS) {
14684                 NDR_CHECK(ndr_pull_align(ndr, 4));
14685                 {
14686                         uint32_t _flags_save_string = ndr->flags;
14687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14688                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14689                         ndr->flags = _flags_save_string;
14690                 }
14691                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14692         }
14693         if (ndr_flags & NDR_BUFFERS) {
14694         }
14695         return NDR_ERR_SUCCESS;
14696 }
14697
14698 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14699 {
14700         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14701         ndr->depth++;
14702         ndr_print_string(ndr, "directory_name", r->directory_name);
14703         ndr->depth--;
14704 }
14705
14706 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14707 {
14708         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14709 }
14710
14711 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14712 {
14713         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14714         if (ndr_flags & NDR_SCALARS) {
14715                 int level = ndr_push_get_switch_value(ndr, r);
14716                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14717                 switch (level) {
14718                         case 1: {
14719                                 NDR_CHECK(ndr_push_align(ndr, 4));
14720                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14721                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14722                         break; }
14723
14724                         default: {
14725                                 NDR_CHECK(ndr_push_align(ndr, 4));
14726                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14727                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14728                         break; }
14729
14730                 }
14731         }
14732         if (ndr_flags & NDR_BUFFERS) {
14733                 int level = ndr_push_get_switch_value(ndr, r);
14734                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14735                 switch (level) {
14736                         case 1:
14737                         break;
14738
14739                         default:
14740                         break;
14741
14742                 }
14743         }
14744         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14745         return NDR_ERR_SUCCESS;
14746 }
14747
14748 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14749 {
14750         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14751         int level;
14752         level = ndr_pull_get_switch_value(ndr, r);
14753         if (ndr_flags & NDR_SCALARS) {
14754                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14755                 switch (level) {
14756                         case 1: {
14757                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14758                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14759                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14760                         break; }
14761
14762                         default: {
14763                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14764                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14765                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14766                         break; }
14767
14768                 }
14769         }
14770         if (ndr_flags & NDR_BUFFERS) {
14771                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14772                 switch (level) {
14773                         case 1:
14774                         break;
14775
14776                         default:
14777                         break;
14778
14779                 }
14780         }
14781         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14782         return NDR_ERR_SUCCESS;
14783 }
14784
14785 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14786 {
14787         int level;
14788         level = ndr_print_get_switch_value(ndr, r);
14789         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14790         switch (level) {
14791                 case 1:
14792                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14793                 break;
14794
14795                 default:
14796                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14797                 break;
14798
14799         }
14800 }
14801
14802 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14803 {
14804         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14805 }
14806
14807 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14808 {
14809         if (ndr_flags & NDR_SCALARS) {
14810                 NDR_CHECK(ndr_push_align(ndr, 5));
14811                 {
14812                         uint32_t _flags_save_string = ndr->flags;
14813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14814                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14815                         ndr->flags = _flags_save_string;
14816                 }
14817                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14818         }
14819         if (ndr_flags & NDR_BUFFERS) {
14820                 {
14821                         uint32_t _flags_save_string = ndr->flags;
14822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14823                         if (r->print_processor_name) {
14824                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
14825                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14826                         }
14827                         ndr->flags = _flags_save_string;
14828                 }
14829         }
14830         return NDR_ERR_SUCCESS;
14831 }
14832
14833 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14834 {
14835         uint32_t _ptr_print_processor_name;
14836         TALLOC_CTX *_mem_save_print_processor_name_0;
14837         if (ndr_flags & NDR_SCALARS) {
14838                 NDR_CHECK(ndr_pull_align(ndr, 5));
14839                 {
14840                         uint32_t _flags_save_string = ndr->flags;
14841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14842                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14843                         if (_ptr_print_processor_name) {
14844                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
14845                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14846                         } else {
14847                                 r->print_processor_name = NULL;
14848                         }
14849                         ndr->flags = _flags_save_string;
14850                 }
14851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14852         }
14853         if (ndr_flags & NDR_BUFFERS) {
14854                 {
14855                         uint32_t _flags_save_string = ndr->flags;
14856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14857                         if (r->print_processor_name) {
14858                                 uint32_t _relative_save_offset;
14859                                 _relative_save_offset = ndr->offset;
14860                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14861                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14862                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14863                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14864                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14865                                 if (ndr->offset > ndr->relative_highest_offset) {
14866                                         ndr->relative_highest_offset = ndr->offset;
14867                                 }
14868                                 ndr->offset = _relative_save_offset;
14869                         }
14870                         ndr->flags = _flags_save_string;
14871                 }
14872         }
14873         return NDR_ERR_SUCCESS;
14874 }
14875
14876 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14877 {
14878         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14879         ndr->depth++;
14880         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14881         ndr->depth++;
14882         if (r->print_processor_name) {
14883                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14884         }
14885         ndr->depth--;
14886         ndr->depth--;
14887 }
14888
14889 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14890 {
14891         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14892 }
14893
14894 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14895 {
14896         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14897         if (ndr_flags & NDR_SCALARS) {
14898                 int level = ndr_push_get_switch_value(ndr, r);
14899                 NDR_CHECK(ndr_push_union_align(ndr, 5));
14900                 switch (level) {
14901                         case 1: {
14902                                 NDR_CHECK(ndr_push_align(ndr, 5));
14903                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14904                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14905                         break; }
14906
14907                         default: {
14908                         break; }
14909
14910                 }
14911         }
14912         if (ndr_flags & NDR_BUFFERS) {
14913                 int level = ndr_push_get_switch_value(ndr, r);
14914                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14915                 switch (level) {
14916                         case 1:
14917                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14918                         break;
14919
14920                         default:
14921                         break;
14922
14923                 }
14924         }
14925         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14926         return NDR_ERR_SUCCESS;
14927 }
14928
14929 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14930 {
14931         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14932         int level;
14933         level = ndr_pull_get_switch_value(ndr, r);
14934         if (ndr_flags & NDR_SCALARS) {
14935                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14936                 switch (level) {
14937                         case 1: {
14938                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14939                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14940                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14941                         break; }
14942
14943                         default: {
14944                         break; }
14945
14946                 }
14947         }
14948         if (ndr_flags & NDR_BUFFERS) {
14949                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14950                 switch (level) {
14951                         case 1:
14952                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14953                         break;
14954
14955                         default:
14956                         break;
14957
14958                 }
14959         }
14960         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14961         return NDR_ERR_SUCCESS;
14962 }
14963
14964 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14965 {
14966         int level;
14967         level = ndr_print_get_switch_value(ndr, r);
14968         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14969         switch (level) {
14970                 case 1:
14971                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14972                 break;
14973
14974                 default:
14975                 break;
14976
14977         }
14978 }
14979
14980 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14981 {
14982         if (ndr_flags & NDR_SCALARS) {
14983                 NDR_CHECK(ndr_push_align(ndr, 4));
14984                 {
14985                         uint32_t _flags_save_string = ndr->flags;
14986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14987                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14988                         ndr->flags = _flags_save_string;
14989                 }
14990                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14991         }
14992         if (ndr_flags & NDR_BUFFERS) {
14993         }
14994         return NDR_ERR_SUCCESS;
14995 }
14996
14997 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14998 {
14999         if (ndr_flags & NDR_SCALARS) {
15000                 NDR_CHECK(ndr_pull_align(ndr, 4));
15001                 {
15002                         uint32_t _flags_save_string = ndr->flags;
15003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15004                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15005                         ndr->flags = _flags_save_string;
15006                 }
15007                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15008         }
15009         if (ndr_flags & NDR_BUFFERS) {
15010         }
15011         return NDR_ERR_SUCCESS;
15012 }
15013
15014 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15015 {
15016         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15017         ndr->depth++;
15018         ndr_print_string(ndr, "directory_name", r->directory_name);
15019         ndr->depth--;
15020 }
15021
15022 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15023 {
15024         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15025 }
15026
15027 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15028 {
15029         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15030         if (ndr_flags & NDR_SCALARS) {
15031                 int level = ndr_push_get_switch_value(ndr, r);
15032                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15033                 switch (level) {
15034                         case 1: {
15035                                 NDR_CHECK(ndr_push_align(ndr, 4));
15036                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15037                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15038                         break; }
15039
15040                         default: {
15041                                 NDR_CHECK(ndr_push_align(ndr, 4));
15042                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15043                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15044                         break; }
15045
15046                 }
15047         }
15048         if (ndr_flags & NDR_BUFFERS) {
15049                 int level = ndr_push_get_switch_value(ndr, r);
15050                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15051                 switch (level) {
15052                         case 1:
15053                         break;
15054
15055                         default:
15056                         break;
15057
15058                 }
15059         }
15060         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15061         return NDR_ERR_SUCCESS;
15062 }
15063
15064 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15065 {
15066         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15067         int level;
15068         level = ndr_pull_get_switch_value(ndr, r);
15069         if (ndr_flags & NDR_SCALARS) {
15070                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15071                 switch (level) {
15072                         case 1: {
15073                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15074                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15075                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15076                         break; }
15077
15078                         default: {
15079                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15080                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15081                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15082                         break; }
15083
15084                 }
15085         }
15086         if (ndr_flags & NDR_BUFFERS) {
15087                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15088                 switch (level) {
15089                         case 1:
15090                         break;
15091
15092                         default:
15093                         break;
15094
15095                 }
15096         }
15097         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15098         return NDR_ERR_SUCCESS;
15099 }
15100
15101 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15102 {
15103         int level;
15104         level = ndr_print_get_switch_value(ndr, r);
15105         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15106         switch (level) {
15107                 case 1:
15108                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15109                 break;
15110
15111                 default:
15112                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15113                 break;
15114
15115         }
15116 }
15117
15118 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15119 {
15120         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15121 }
15122
15123 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15124 {
15125         if (ndr_flags & NDR_SCALARS) {
15126                 NDR_CHECK(ndr_push_align(ndr, 5));
15127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15130                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15131         }
15132         if (ndr_flags & NDR_BUFFERS) {
15133                 if (r->document_name) {
15134                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15135                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15136                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15137                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15138                 }
15139                 if (r->output_file) {
15140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15141                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15143                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15144                 }
15145                 if (r->datatype) {
15146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15147                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15149                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15150                 }
15151         }
15152         return NDR_ERR_SUCCESS;
15153 }
15154
15155 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15156 {
15157         uint32_t _ptr_document_name;
15158         TALLOC_CTX *_mem_save_document_name_0;
15159         uint32_t _ptr_output_file;
15160         TALLOC_CTX *_mem_save_output_file_0;
15161         uint32_t _ptr_datatype;
15162         TALLOC_CTX *_mem_save_datatype_0;
15163         if (ndr_flags & NDR_SCALARS) {
15164                 NDR_CHECK(ndr_pull_align(ndr, 5));
15165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15166                 if (_ptr_document_name) {
15167                         NDR_PULL_ALLOC(ndr, r->document_name);
15168                 } else {
15169                         r->document_name = NULL;
15170                 }
15171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15172                 if (_ptr_output_file) {
15173                         NDR_PULL_ALLOC(ndr, r->output_file);
15174                 } else {
15175                         r->output_file = NULL;
15176                 }
15177                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15178                 if (_ptr_datatype) {
15179                         NDR_PULL_ALLOC(ndr, r->datatype);
15180                 } else {
15181                         r->datatype = NULL;
15182                 }
15183                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15184         }
15185         if (ndr_flags & NDR_BUFFERS) {
15186                 if (r->document_name) {
15187                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15188                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15191                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15192                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
15193                         }
15194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15197                 }
15198                 if (r->output_file) {
15199                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15200                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15203                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15204                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->output_file), ndr_get_array_length(ndr, &r->output_file));
15205                         }
15206                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15209                 }
15210                 if (r->datatype) {
15211                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15212                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15214                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15215                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15216                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
15217                         }
15218                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15221                 }
15222         }
15223         return NDR_ERR_SUCCESS;
15224 }
15225
15226 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15227 {
15228         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15229         ndr->depth++;
15230         ndr_print_ptr(ndr, "document_name", r->document_name);
15231         ndr->depth++;
15232         if (r->document_name) {
15233                 ndr_print_string(ndr, "document_name", r->document_name);
15234         }
15235         ndr->depth--;
15236         ndr_print_ptr(ndr, "output_file", r->output_file);
15237         ndr->depth++;
15238         if (r->output_file) {
15239                 ndr_print_string(ndr, "output_file", r->output_file);
15240         }
15241         ndr->depth--;
15242         ndr_print_ptr(ndr, "datatype", r->datatype);
15243         ndr->depth++;
15244         if (r->datatype) {
15245                 ndr_print_string(ndr, "datatype", r->datatype);
15246         }
15247         ndr->depth--;
15248         ndr->depth--;
15249 }
15250
15251 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15252 {
15253         if (ndr_flags & NDR_SCALARS) {
15254                 int level = ndr_push_get_switch_value(ndr, r);
15255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15256                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15257                 switch (level) {
15258                         case 1: {
15259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15260                         break; }
15261
15262                         case 2: {
15263                         break; }
15264
15265                         case 3: {
15266                         break; }
15267
15268                         default: {
15269                         break; }
15270
15271                 }
15272         }
15273         if (ndr_flags & NDR_BUFFERS) {
15274                 int level = ndr_push_get_switch_value(ndr, r);
15275                 switch (level) {
15276                         case 1:
15277                                 if (r->info1) {
15278                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15279                                 }
15280                         break;
15281
15282                         case 2:
15283                         break;
15284
15285                         case 3:
15286                         break;
15287
15288                         default:
15289                         break;
15290
15291                 }
15292         }
15293         return NDR_ERR_SUCCESS;
15294 }
15295
15296 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15297 {
15298         int level;
15299         uint32_t _level;
15300         TALLOC_CTX *_mem_save_info1_0;
15301         level = ndr_pull_get_switch_value(ndr, r);
15302         if (ndr_flags & NDR_SCALARS) {
15303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15304                 if (_level != level) {
15305                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15306                 }
15307                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15308                 switch (level) {
15309                         case 1: {
15310                                 uint32_t _ptr_info1;
15311                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15312                                 if (_ptr_info1) {
15313                                         NDR_PULL_ALLOC(ndr, r->info1);
15314                                 } else {
15315                                         r->info1 = NULL;
15316                                 }
15317                         break; }
15318
15319                         case 2: {
15320                         break; }
15321
15322                         case 3: {
15323                         break; }
15324
15325                         default: {
15326                         break; }
15327
15328                 }
15329         }
15330         if (ndr_flags & NDR_BUFFERS) {
15331                 switch (level) {
15332                         case 1:
15333                                 if (r->info1) {
15334                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15335                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15336                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15338                                 }
15339                         break;
15340
15341                         case 2:
15342                         break;
15343
15344                         case 3:
15345                         break;
15346
15347                         default:
15348                         break;
15349
15350                 }
15351         }
15352         return NDR_ERR_SUCCESS;
15353 }
15354
15355 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15356 {
15357         int level;
15358         level = ndr_print_get_switch_value(ndr, r);
15359         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15360         switch (level) {
15361                 case 1:
15362                         ndr_print_ptr(ndr, "info1", r->info1);
15363                         ndr->depth++;
15364                         if (r->info1) {
15365                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15366                         }
15367                         ndr->depth--;
15368                 break;
15369
15370                 case 2:
15371                 break;
15372
15373                 case 3:
15374                 break;
15375
15376                 default:
15377                 break;
15378
15379         }
15380 }
15381
15382 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15383 {
15384         if (ndr_flags & NDR_SCALARS) {
15385                 NDR_CHECK(ndr_push_align(ndr, 4));
15386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15391                 {
15392                         uint32_t _flags_save_string = ndr->flags;
15393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15394                         {
15395                                 struct ndr_push *_ndr_extra_string;
15396                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15397                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15398                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15399                         }
15400                         ndr->flags = _flags_save_string;
15401                 }
15402                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15403         }
15404         if (ndr_flags & NDR_BUFFERS) {
15405         }
15406         return NDR_ERR_SUCCESS;
15407 }
15408
15409 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15410 {
15411         if (ndr_flags & NDR_SCALARS) {
15412                 NDR_CHECK(ndr_pull_align(ndr, 4));
15413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15418                 {
15419                         uint32_t _flags_save_string = ndr->flags;
15420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15421                         {
15422                                 struct ndr_pull *_ndr_extra_string;
15423                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15424                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15425                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15426                         }
15427                         ndr->flags = _flags_save_string;
15428                 }
15429                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15430         }
15431         if (ndr_flags & NDR_BUFFERS) {
15432         }
15433         return NDR_ERR_SUCCESS;
15434 }
15435
15436 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15437 {
15438         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15439         ndr->depth++;
15440         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
15441         ndr_print_uint32(ndr, "major", r->major);
15442         ndr_print_uint32(ndr, "minor", r->minor);
15443         ndr_print_uint32(ndr, "build", r->build);
15444         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15445         ndr_print_string(ndr, "extra_string", r->extra_string);
15446         ndr->depth--;
15447 }
15448
15449 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15450 {
15451         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15452 }
15453
15454 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15455 {
15456         if (ndr_flags & NDR_SCALARS) {
15457                 NDR_CHECK(ndr_push_align(ndr, 4));
15458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15463                 {
15464                         uint32_t _flags_save_string = ndr->flags;
15465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15466                         {
15467                                 struct ndr_push *_ndr_extra_string;
15468                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15469                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15470                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15471                         }
15472                         ndr->flags = _flags_save_string;
15473                 }
15474                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15475                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15476                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15477                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15478                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15479                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15480         }
15481         if (ndr_flags & NDR_BUFFERS) {
15482         }
15483         return NDR_ERR_SUCCESS;
15484 }
15485
15486 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15487 {
15488         if (ndr_flags & NDR_SCALARS) {
15489                 NDR_CHECK(ndr_pull_align(ndr, 4));
15490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15495                 {
15496                         uint32_t _flags_save_string = ndr->flags;
15497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15498                         {
15499                                 struct ndr_pull *_ndr_extra_string;
15500                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15501                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15502                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15503                         }
15504                         ndr->flags = _flags_save_string;
15505                 }
15506                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15507                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15508                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15509                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15510                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15512         }
15513         if (ndr_flags & NDR_BUFFERS) {
15514         }
15515         return NDR_ERR_SUCCESS;
15516 }
15517
15518 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15519 {
15520         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15521         ndr->depth++;
15522         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
15523         ndr_print_uint32(ndr, "major", r->major);
15524         ndr_print_uint32(ndr, "minor", r->minor);
15525         ndr_print_uint32(ndr, "build", r->build);
15526         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15527         ndr_print_string(ndr, "extra_string", r->extra_string);
15528         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15529         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15530         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15531         ndr_print_uint8(ndr, "product_type", r->product_type);
15532         ndr_print_uint8(ndr, "reserved", r->reserved);
15533         ndr->depth--;
15534 }
15535
15536 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15537 {
15538         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15539 }
15540
15541 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15542 {
15543         if (ndr_flags & NDR_SCALARS) {
15544                 int level = ndr_push_get_switch_value(ndr, r);
15545                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15546                 switch (level) {
15547                         case REG_NONE: {
15548                         break; }
15549
15550                         case REG_SZ: {
15551                                 {
15552                                         uint32_t _flags_save_string = ndr->flags;
15553                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15554                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15555                                         ndr->flags = _flags_save_string;
15556                                 }
15557                         break; }
15558
15559                         case REG_BINARY: {
15560                                 {
15561                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15562                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15563                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15564                                         ndr->flags = _flags_save_DATA_BLOB;
15565                                 }
15566                         break; }
15567
15568                         case REG_DWORD: {
15569                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15570                         break; }
15571
15572                         case REG_MULTI_SZ: {
15573                                 {
15574                                         uint32_t _flags_save_string_array = ndr->flags;
15575                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15576                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15577                                         ndr->flags = _flags_save_string_array;
15578                                 }
15579                         break; }
15580
15581                         default: {
15582                                 {
15583                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15584                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15585                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15586                                         ndr->flags = _flags_save_DATA_BLOB;
15587                                 }
15588                         break; }
15589
15590                 }
15591         }
15592         if (ndr_flags & NDR_BUFFERS) {
15593                 int level = ndr_push_get_switch_value(ndr, r);
15594                 switch (level) {
15595                         case REG_NONE:
15596                         break;
15597
15598                         case REG_SZ:
15599                         break;
15600
15601                         case REG_BINARY:
15602                         break;
15603
15604                         case REG_DWORD:
15605                         break;
15606
15607                         case REG_MULTI_SZ:
15608                         break;
15609
15610                         default:
15611                         break;
15612
15613                 }
15614         }
15615         return NDR_ERR_SUCCESS;
15616 }
15617
15618 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15619 {
15620         int level;
15621         level = ndr_pull_get_switch_value(ndr, r);
15622         if (ndr_flags & NDR_SCALARS) {
15623                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15624                 switch (level) {
15625                         case REG_NONE: {
15626                         break; }
15627
15628                         case REG_SZ: {
15629                                 {
15630                                         uint32_t _flags_save_string = ndr->flags;
15631                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15632                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15633                                         ndr->flags = _flags_save_string;
15634                                 }
15635                         break; }
15636
15637                         case REG_BINARY: {
15638                                 {
15639                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15640                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15641                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15642                                         ndr->flags = _flags_save_DATA_BLOB;
15643                                 }
15644                         break; }
15645
15646                         case REG_DWORD: {
15647                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15648                         break; }
15649
15650                         case REG_MULTI_SZ: {
15651                                 {
15652                                         uint32_t _flags_save_string_array = ndr->flags;
15653                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15654                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15655                                         ndr->flags = _flags_save_string_array;
15656                                 }
15657                         break; }
15658
15659                         default: {
15660                                 {
15661                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15662                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15663                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15664                                         ndr->flags = _flags_save_DATA_BLOB;
15665                                 }
15666                         break; }
15667
15668                 }
15669         }
15670         if (ndr_flags & NDR_BUFFERS) {
15671                 switch (level) {
15672                         case REG_NONE:
15673                         break;
15674
15675                         case REG_SZ:
15676                         break;
15677
15678                         case REG_BINARY:
15679                         break;
15680
15681                         case REG_DWORD:
15682                         break;
15683
15684                         case REG_MULTI_SZ:
15685                         break;
15686
15687                         default:
15688                         break;
15689
15690                 }
15691         }
15692         return NDR_ERR_SUCCESS;
15693 }
15694
15695 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15696 {
15697         int level;
15698         level = ndr_print_get_switch_value(ndr, r);
15699         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15700         switch (level) {
15701                 case REG_NONE:
15702                 break;
15703
15704                 case REG_SZ:
15705                         ndr_print_string(ndr, "string", r->string);
15706                 break;
15707
15708                 case REG_BINARY:
15709                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15710                 break;
15711
15712                 case REG_DWORD:
15713                         ndr_print_uint32(ndr, "value", r->value);
15714                 break;
15715
15716                 case REG_MULTI_SZ:
15717                         ndr_print_string_array(ndr, "string_array", r->string_array);
15718                 break;
15719
15720                 default:
15721                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15722                 break;
15723
15724         }
15725 }
15726
15727 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15728 {
15729         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
15730 }
15731
15732 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15733 {
15734         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15735         return NDR_ERR_SUCCESS;
15736 }
15737
15738 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15739 {
15740         uint32_t v;
15741         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15742         *r = v;
15743         return NDR_ERR_SUCCESS;
15744 }
15745
15746 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15747 {
15748         const char *val = NULL;
15749
15750         switch (r) {
15751                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15752                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15753                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15754         }
15755         ndr_print_enum(ndr, name, "ENUM", val, r);
15756 }
15757
15758 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15759 {
15760         if (ndr_flags & NDR_SCALARS) {
15761                 NDR_CHECK(ndr_push_align(ndr, 4));
15762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15764                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15765         }
15766         if (ndr_flags & NDR_BUFFERS) {
15767         }
15768         return NDR_ERR_SUCCESS;
15769 }
15770
15771 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15772 {
15773         if (ndr_flags & NDR_SCALARS) {
15774                 NDR_CHECK(ndr_pull_align(ndr, 4));
15775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15777                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15778         }
15779         if (ndr_flags & NDR_BUFFERS) {
15780         }
15781         return NDR_ERR_SUCCESS;
15782 }
15783
15784 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15785 {
15786         ndr_print_struct(ndr, name, "spoolss_FormSize");
15787         ndr->depth++;
15788         ndr_print_uint32(ndr, "width", r->width);
15789         ndr_print_uint32(ndr, "height", r->height);
15790         ndr->depth--;
15791 }
15792
15793 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15794 {
15795         if (ndr_flags & NDR_SCALARS) {
15796                 NDR_CHECK(ndr_push_align(ndr, 4));
15797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15801                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15802         }
15803         if (ndr_flags & NDR_BUFFERS) {
15804         }
15805         return NDR_ERR_SUCCESS;
15806 }
15807
15808 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15809 {
15810         if (ndr_flags & NDR_SCALARS) {
15811                 NDR_CHECK(ndr_pull_align(ndr, 4));
15812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15816                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15817         }
15818         if (ndr_flags & NDR_BUFFERS) {
15819         }
15820         return NDR_ERR_SUCCESS;
15821 }
15822
15823 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15824 {
15825         ndr_print_struct(ndr, name, "spoolss_FormArea");
15826         ndr->depth++;
15827         ndr_print_uint32(ndr, "left", r->left);
15828         ndr_print_uint32(ndr, "top", r->top);
15829         ndr_print_uint32(ndr, "right", r->right);
15830         ndr_print_uint32(ndr, "bottom", r->bottom);
15831         ndr->depth--;
15832 }
15833
15834 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15835 {
15836         if (ndr_flags & NDR_SCALARS) {
15837                 NDR_CHECK(ndr_push_align(ndr, 5));
15838                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15839                 {
15840                         uint32_t _flags_save_string = ndr->flags;
15841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15842                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15843                         ndr->flags = _flags_save_string;
15844                 }
15845                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15846                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15847                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15848         }
15849         if (ndr_flags & NDR_BUFFERS) {
15850                 {
15851                         uint32_t _flags_save_string = ndr->flags;
15852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15853                         if (r->form_name) {
15854                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15855                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15856                         }
15857                         ndr->flags = _flags_save_string;
15858                 }
15859         }
15860         return NDR_ERR_SUCCESS;
15861 }
15862
15863 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15864 {
15865         uint32_t _ptr_form_name;
15866         TALLOC_CTX *_mem_save_form_name_0;
15867         if (ndr_flags & NDR_SCALARS) {
15868                 NDR_CHECK(ndr_pull_align(ndr, 5));
15869                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15870                 {
15871                         uint32_t _flags_save_string = ndr->flags;
15872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15873                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15874                         if (_ptr_form_name) {
15875                                 NDR_PULL_ALLOC(ndr, r->form_name);
15876                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15877                         } else {
15878                                 r->form_name = NULL;
15879                         }
15880                         ndr->flags = _flags_save_string;
15881                 }
15882                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15883                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15884                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15885         }
15886         if (ndr_flags & NDR_BUFFERS) {
15887                 {
15888                         uint32_t _flags_save_string = ndr->flags;
15889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15890                         if (r->form_name) {
15891                                 uint32_t _relative_save_offset;
15892                                 _relative_save_offset = ndr->offset;
15893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15894                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15895                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15896                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15898                                 if (ndr->offset > ndr->relative_highest_offset) {
15899                                         ndr->relative_highest_offset = ndr->offset;
15900                                 }
15901                                 ndr->offset = _relative_save_offset;
15902                         }
15903                         ndr->flags = _flags_save_string;
15904                 }
15905         }
15906         return NDR_ERR_SUCCESS;
15907 }
15908
15909 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15910 {
15911         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15912         ndr->depth++;
15913         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15914         ndr_print_ptr(ndr, "form_name", r->form_name);
15915         ndr->depth++;
15916         if (r->form_name) {
15917                 ndr_print_string(ndr, "form_name", r->form_name);
15918         }
15919         ndr->depth--;
15920         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15921         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15922         ndr->depth--;
15923 }
15924
15925 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15926 {
15927         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15928 }
15929
15930 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15931 {
15932         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15933         return NDR_ERR_SUCCESS;
15934 }
15935
15936 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15937 {
15938         uint32_t v;
15939         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15940         *r = v;
15941         return NDR_ERR_SUCCESS;
15942 }
15943
15944 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15945 {
15946         ndr_print_uint32(ndr, name, r);
15947         ndr->depth++;
15948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15950         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15951         ndr->depth--;
15952 }
15953
15954 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15955 {
15956         if (ndr_flags & NDR_SCALARS) {
15957                 NDR_CHECK(ndr_push_align(ndr, 5));
15958                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15959                 {
15960                         uint32_t _flags_save_string = ndr->flags;
15961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15962                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15963                         ndr->flags = _flags_save_string;
15964                 }
15965                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15966                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15967                 {
15968                         uint32_t _flags_save_string = ndr->flags;
15969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15970                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15971                         ndr->flags = _flags_save_string;
15972                 }
15973                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15974                 {
15975                         uint32_t _flags_save_string = ndr->flags;
15976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15977                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15978                         ndr->flags = _flags_save_string;
15979                 }
15980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15981                 {
15982                         uint32_t _flags_save_string = ndr->flags;
15983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15984                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15985                         ndr->flags = _flags_save_string;
15986                 }
15987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15988                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15989         }
15990         if (ndr_flags & NDR_BUFFERS) {
15991                 {
15992                         uint32_t _flags_save_string = ndr->flags;
15993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15994                         if (r->form_name) {
15995                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15996                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15997                         }
15998                         ndr->flags = _flags_save_string;
15999                 }
16000                 {
16001                         uint32_t _flags_save_string = ndr->flags;
16002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16003                         if (r->keyword) {
16004                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
16005                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16006                         }
16007                         ndr->flags = _flags_save_string;
16008                 }
16009                 {
16010                         uint32_t _flags_save_string = ndr->flags;
16011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16012                         if (r->mui_dll) {
16013                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
16014                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16015                         }
16016                         ndr->flags = _flags_save_string;
16017                 }
16018                 {
16019                         uint32_t _flags_save_string = ndr->flags;
16020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16021                         if (r->display_name) {
16022                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
16023                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16024                         }
16025                         ndr->flags = _flags_save_string;
16026                 }
16027         }
16028         return NDR_ERR_SUCCESS;
16029 }
16030
16031 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16032 {
16033         uint32_t _ptr_form_name;
16034         TALLOC_CTX *_mem_save_form_name_0;
16035         uint32_t _ptr_keyword;
16036         TALLOC_CTX *_mem_save_keyword_0;
16037         uint32_t _ptr_mui_dll;
16038         TALLOC_CTX *_mem_save_mui_dll_0;
16039         uint32_t _ptr_display_name;
16040         TALLOC_CTX *_mem_save_display_name_0;
16041         if (ndr_flags & NDR_SCALARS) {
16042                 NDR_CHECK(ndr_pull_align(ndr, 5));
16043                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16044                 {
16045                         uint32_t _flags_save_string = ndr->flags;
16046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16047                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16048                         if (_ptr_form_name) {
16049                                 NDR_PULL_ALLOC(ndr, r->form_name);
16050                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16051                         } else {
16052                                 r->form_name = NULL;
16053                         }
16054                         ndr->flags = _flags_save_string;
16055                 }
16056                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16057                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16058                 {
16059                         uint32_t _flags_save_string = ndr->flags;
16060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16061                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16062                         if (_ptr_keyword) {
16063                                 NDR_PULL_ALLOC(ndr, r->keyword);
16064                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16065                         } else {
16066                                 r->keyword = NULL;
16067                         }
16068                         ndr->flags = _flags_save_string;
16069                 }
16070                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16071                 {
16072                         uint32_t _flags_save_string = ndr->flags;
16073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16074                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16075                         if (_ptr_mui_dll) {
16076                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16077                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16078                         } else {
16079                                 r->mui_dll = NULL;
16080                         }
16081                         ndr->flags = _flags_save_string;
16082                 }
16083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16084                 {
16085                         uint32_t _flags_save_string = ndr->flags;
16086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16087                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16088                         if (_ptr_display_name) {
16089                                 NDR_PULL_ALLOC(ndr, r->display_name);
16090                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16091                         } else {
16092                                 r->display_name = NULL;
16093                         }
16094                         ndr->flags = _flags_save_string;
16095                 }
16096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16097                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16098         }
16099         if (ndr_flags & NDR_BUFFERS) {
16100                 {
16101                         uint32_t _flags_save_string = ndr->flags;
16102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16103                         if (r->form_name) {
16104                                 uint32_t _relative_save_offset;
16105                                 _relative_save_offset = ndr->offset;
16106                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16107                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16108                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16109                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16110                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16111                                 if (ndr->offset > ndr->relative_highest_offset) {
16112                                         ndr->relative_highest_offset = ndr->offset;
16113                                 }
16114                                 ndr->offset = _relative_save_offset;
16115                         }
16116                         ndr->flags = _flags_save_string;
16117                 }
16118                 {
16119                         uint32_t _flags_save_string = ndr->flags;
16120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16121                         if (r->keyword) {
16122                                 uint32_t _relative_save_offset;
16123                                 _relative_save_offset = ndr->offset;
16124                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16125                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16126                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16127                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16128                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16129                                 if (ndr->offset > ndr->relative_highest_offset) {
16130                                         ndr->relative_highest_offset = ndr->offset;
16131                                 }
16132                                 ndr->offset = _relative_save_offset;
16133                         }
16134                         ndr->flags = _flags_save_string;
16135                 }
16136                 {
16137                         uint32_t _flags_save_string = ndr->flags;
16138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16139                         if (r->mui_dll) {
16140                                 uint32_t _relative_save_offset;
16141                                 _relative_save_offset = ndr->offset;
16142                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16143                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16144                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16145                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16146                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16147                                 if (ndr->offset > ndr->relative_highest_offset) {
16148                                         ndr->relative_highest_offset = ndr->offset;
16149                                 }
16150                                 ndr->offset = _relative_save_offset;
16151                         }
16152                         ndr->flags = _flags_save_string;
16153                 }
16154                 {
16155                         uint32_t _flags_save_string = ndr->flags;
16156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16157                         if (r->display_name) {
16158                                 uint32_t _relative_save_offset;
16159                                 _relative_save_offset = ndr->offset;
16160                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16161                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16162                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16163                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16164                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16165                                 if (ndr->offset > ndr->relative_highest_offset) {
16166                                         ndr->relative_highest_offset = ndr->offset;
16167                                 }
16168                                 ndr->offset = _relative_save_offset;
16169                         }
16170                         ndr->flags = _flags_save_string;
16171                 }
16172         }
16173         return NDR_ERR_SUCCESS;
16174 }
16175
16176 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16177 {
16178         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16179         ndr->depth++;
16180         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16181         ndr_print_ptr(ndr, "form_name", r->form_name);
16182         ndr->depth++;
16183         if (r->form_name) {
16184                 ndr_print_string(ndr, "form_name", r->form_name);
16185         }
16186         ndr->depth--;
16187         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16188         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16189         ndr_print_ptr(ndr, "keyword", r->keyword);
16190         ndr->depth++;
16191         if (r->keyword) {
16192                 ndr_print_string(ndr, "keyword", r->keyword);
16193         }
16194         ndr->depth--;
16195         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16196         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16197         ndr->depth++;
16198         if (r->mui_dll) {
16199                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16200         }
16201         ndr->depth--;
16202         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16203         ndr_print_ptr(ndr, "display_name", r->display_name);
16204         ndr->depth++;
16205         if (r->display_name) {
16206                 ndr_print_string(ndr, "display_name", r->display_name);
16207         }
16208         ndr->depth--;
16209         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16210         ndr->depth--;
16211 }
16212
16213 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16214 {
16215         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16216 }
16217
16218 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16219 {
16220         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16221         if (ndr_flags & NDR_SCALARS) {
16222                 int level = ndr_push_get_switch_value(ndr, r);
16223                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16224                 switch (level) {
16225                         case 1: {
16226                                 NDR_CHECK(ndr_push_align(ndr, 5));
16227                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16228                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16229                         break; }
16230
16231                         case 2: {
16232                                 NDR_CHECK(ndr_push_align(ndr, 5));
16233                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16234                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16235                         break; }
16236
16237                         default: {
16238                         break; }
16239
16240                 }
16241         }
16242         if (ndr_flags & NDR_BUFFERS) {
16243                 int level = ndr_push_get_switch_value(ndr, r);
16244                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16245                 switch (level) {
16246                         case 1:
16247                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16248                         break;
16249
16250                         case 2:
16251                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16252                         break;
16253
16254                         default:
16255                         break;
16256
16257                 }
16258         }
16259         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16260         return NDR_ERR_SUCCESS;
16261 }
16262
16263 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16264 {
16265         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16266         int level;
16267         level = ndr_pull_get_switch_value(ndr, r);
16268         if (ndr_flags & NDR_SCALARS) {
16269                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16270                 switch (level) {
16271                         case 1: {
16272                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16273                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16274                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16275                         break; }
16276
16277                         case 2: {
16278                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16279                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16280                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16281                         break; }
16282
16283                         default: {
16284                         break; }
16285
16286                 }
16287         }
16288         if (ndr_flags & NDR_BUFFERS) {
16289                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16290                 switch (level) {
16291                         case 1:
16292                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16293                         break;
16294
16295                         case 2:
16296                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16297                         break;
16298
16299                         default:
16300                         break;
16301
16302                 }
16303         }
16304         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16305         return NDR_ERR_SUCCESS;
16306 }
16307
16308 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16309 {
16310         int level;
16311         level = ndr_print_get_switch_value(ndr, r);
16312         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16313         switch (level) {
16314                 case 1:
16315                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16316                 break;
16317
16318                 case 2:
16319                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16320                 break;
16321
16322                 default:
16323                 break;
16324
16325         }
16326 }
16327
16328 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16329 {
16330         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16331 }
16332
16333 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16334 {
16335         if (ndr_flags & NDR_SCALARS) {
16336                 NDR_CHECK(ndr_push_align(ndr, 5));
16337                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16338                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16339                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16340                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16341                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16342         }
16343         if (ndr_flags & NDR_BUFFERS) {
16344                 if (r->form_name) {
16345                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16346                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16347                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16348                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16349                 }
16350         }
16351         return NDR_ERR_SUCCESS;
16352 }
16353
16354 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16355 {
16356         uint32_t _ptr_form_name;
16357         TALLOC_CTX *_mem_save_form_name_0;
16358         if (ndr_flags & NDR_SCALARS) {
16359                 NDR_CHECK(ndr_pull_align(ndr, 5));
16360                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16362                 if (_ptr_form_name) {
16363                         NDR_PULL_ALLOC(ndr, r->form_name);
16364                 } else {
16365                         r->form_name = NULL;
16366                 }
16367                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16368                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16369                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16370         }
16371         if (ndr_flags & NDR_BUFFERS) {
16372                 if (r->form_name) {
16373                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16374                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16375                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16376                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16377                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16378                                 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));
16379                         }
16380                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16381                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16382                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16383                 }
16384         }
16385         return NDR_ERR_SUCCESS;
16386 }
16387
16388 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16389 {
16390         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16391         ndr->depth++;
16392         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16393         ndr_print_ptr(ndr, "form_name", r->form_name);
16394         ndr->depth++;
16395         if (r->form_name) {
16396                 ndr_print_string(ndr, "form_name", r->form_name);
16397         }
16398         ndr->depth--;
16399         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16400         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16401         ndr->depth--;
16402 }
16403
16404 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16405 {
16406         if (ndr_flags & NDR_SCALARS) {
16407                 NDR_CHECK(ndr_push_align(ndr, 5));
16408                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16410                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16411                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16413                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16418                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16419         }
16420         if (ndr_flags & NDR_BUFFERS) {
16421                 if (r->form_name) {
16422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16426                 }
16427                 if (r->keyword) {
16428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16432                 }
16433                 if (r->mui_dll) {
16434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16436                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16438                 }
16439                 if (r->display_name) {
16440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16444                 }
16445         }
16446         return NDR_ERR_SUCCESS;
16447 }
16448
16449 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16450 {
16451         uint32_t _ptr_form_name;
16452         TALLOC_CTX *_mem_save_form_name_0;
16453         uint32_t _ptr_keyword;
16454         TALLOC_CTX *_mem_save_keyword_0;
16455         uint32_t _ptr_mui_dll;
16456         TALLOC_CTX *_mem_save_mui_dll_0;
16457         uint32_t _ptr_display_name;
16458         TALLOC_CTX *_mem_save_display_name_0;
16459         if (ndr_flags & NDR_SCALARS) {
16460                 NDR_CHECK(ndr_pull_align(ndr, 5));
16461                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16463                 if (_ptr_form_name) {
16464                         NDR_PULL_ALLOC(ndr, r->form_name);
16465                 } else {
16466                         r->form_name = NULL;
16467                 }
16468                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16469                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16471                 if (_ptr_keyword) {
16472                         NDR_PULL_ALLOC(ndr, r->keyword);
16473                 } else {
16474                         r->keyword = NULL;
16475                 }
16476                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16478                 if (_ptr_mui_dll) {
16479                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16480                 } else {
16481                         r->mui_dll = NULL;
16482                 }
16483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16485                 if (_ptr_display_name) {
16486                         NDR_PULL_ALLOC(ndr, r->display_name);
16487                 } else {
16488                         r->display_name = NULL;
16489                 }
16490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16491                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16492         }
16493         if (ndr_flags & NDR_BUFFERS) {
16494                 if (r->form_name) {
16495                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16496                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16499                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16500                                 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));
16501                         }
16502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16505                 }
16506                 if (r->keyword) {
16507                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16508                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16511                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16512                                 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));
16513                         }
16514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16517                 }
16518                 if (r->mui_dll) {
16519                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16520                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16521                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16522                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16523                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16524                                 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));
16525                         }
16526                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16527                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16529                 }
16530                 if (r->display_name) {
16531                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16532                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16533                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16534                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16535                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16536                                 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));
16537                         }
16538                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16539                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16541                 }
16542         }
16543         return NDR_ERR_SUCCESS;
16544 }
16545
16546 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16547 {
16548         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16549         ndr->depth++;
16550         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16551         ndr_print_ptr(ndr, "form_name", r->form_name);
16552         ndr->depth++;
16553         if (r->form_name) {
16554                 ndr_print_string(ndr, "form_name", r->form_name);
16555         }
16556         ndr->depth--;
16557         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16558         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16559         ndr_print_ptr(ndr, "keyword", r->keyword);
16560         ndr->depth++;
16561         if (r->keyword) {
16562                 ndr_print_string(ndr, "keyword", r->keyword);
16563         }
16564         ndr->depth--;
16565         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16566         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16567         ndr->depth++;
16568         if (r->mui_dll) {
16569                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16570         }
16571         ndr->depth--;
16572         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16573         ndr_print_ptr(ndr, "display_name", r->display_name);
16574         ndr->depth++;
16575         if (r->display_name) {
16576                 ndr_print_string(ndr, "display_name", r->display_name);
16577         }
16578         ndr->depth--;
16579         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16580         ndr->depth--;
16581 }
16582
16583 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16584 {
16585         if (ndr_flags & NDR_SCALARS) {
16586                 int level = ndr_push_get_switch_value(ndr, r);
16587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16588                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16589                 switch (level) {
16590                         case 1: {
16591                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16592                         break; }
16593
16594                         case 2: {
16595                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16596                         break; }
16597
16598                         default:
16599                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16600                 }
16601         }
16602         if (ndr_flags & NDR_BUFFERS) {
16603                 int level = ndr_push_get_switch_value(ndr, r);
16604                 switch (level) {
16605                         case 1:
16606                                 if (r->info1) {
16607                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16608                                 }
16609                         break;
16610
16611                         case 2:
16612                                 if (r->info2) {
16613                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16614                                 }
16615                         break;
16616
16617                         default:
16618                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16619                 }
16620         }
16621         return NDR_ERR_SUCCESS;
16622 }
16623
16624 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16625 {
16626         int level;
16627         uint32_t _level;
16628         TALLOC_CTX *_mem_save_info1_0;
16629         TALLOC_CTX *_mem_save_info2_0;
16630         level = ndr_pull_get_switch_value(ndr, r);
16631         if (ndr_flags & NDR_SCALARS) {
16632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16633                 if (_level != level) {
16634                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16635                 }
16636                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16637                 switch (level) {
16638                         case 1: {
16639                                 uint32_t _ptr_info1;
16640                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16641                                 if (_ptr_info1) {
16642                                         NDR_PULL_ALLOC(ndr, r->info1);
16643                                 } else {
16644                                         r->info1 = NULL;
16645                                 }
16646                         break; }
16647
16648                         case 2: {
16649                                 uint32_t _ptr_info2;
16650                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16651                                 if (_ptr_info2) {
16652                                         NDR_PULL_ALLOC(ndr, r->info2);
16653                                 } else {
16654                                         r->info2 = NULL;
16655                                 }
16656                         break; }
16657
16658                         default:
16659                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16660                 }
16661         }
16662         if (ndr_flags & NDR_BUFFERS) {
16663                 switch (level) {
16664                         case 1:
16665                                 if (r->info1) {
16666                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16667                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16668                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16669                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16670                                 }
16671                         break;
16672
16673                         case 2:
16674                                 if (r->info2) {
16675                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16676                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16677                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16678                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16679                                 }
16680                         break;
16681
16682                         default:
16683                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16684                 }
16685         }
16686         return NDR_ERR_SUCCESS;
16687 }
16688
16689 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16690 {
16691         int level;
16692         level = ndr_print_get_switch_value(ndr, r);
16693         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16694         switch (level) {
16695                 case 1:
16696                         ndr_print_ptr(ndr, "info1", r->info1);
16697                         ndr->depth++;
16698                         if (r->info1) {
16699                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16700                         }
16701                         ndr->depth--;
16702                 break;
16703
16704                 case 2:
16705                         ndr_print_ptr(ndr, "info2", r->info2);
16706                         ndr->depth++;
16707                         if (r->info2) {
16708                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16709                         }
16710                         ndr->depth--;
16711                 break;
16712
16713                 default:
16714                         ndr_print_bad_level(ndr, name, level);
16715         }
16716 }
16717
16718 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16719 {
16720         if (ndr_flags & NDR_SCALARS) {
16721                 NDR_CHECK(ndr_push_align(ndr, 5));
16722                 {
16723                         uint32_t _flags_save_string = ndr->flags;
16724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16725                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16726                         ndr->flags = _flags_save_string;
16727                 }
16728                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16729         }
16730         if (ndr_flags & NDR_BUFFERS) {
16731                 {
16732                         uint32_t _flags_save_string = ndr->flags;
16733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16734                         if (r->port_name) {
16735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16737                         }
16738                         ndr->flags = _flags_save_string;
16739                 }
16740         }
16741         return NDR_ERR_SUCCESS;
16742 }
16743
16744 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16745 {
16746         uint32_t _ptr_port_name;
16747         TALLOC_CTX *_mem_save_port_name_0;
16748         if (ndr_flags & NDR_SCALARS) {
16749                 NDR_CHECK(ndr_pull_align(ndr, 5));
16750                 {
16751                         uint32_t _flags_save_string = ndr->flags;
16752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16754                         if (_ptr_port_name) {
16755                                 NDR_PULL_ALLOC(ndr, r->port_name);
16756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16757                         } else {
16758                                 r->port_name = NULL;
16759                         }
16760                         ndr->flags = _flags_save_string;
16761                 }
16762                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16763         }
16764         if (ndr_flags & NDR_BUFFERS) {
16765                 {
16766                         uint32_t _flags_save_string = ndr->flags;
16767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16768                         if (r->port_name) {
16769                                 uint32_t _relative_save_offset;
16770                                 _relative_save_offset = ndr->offset;
16771                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16772                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16773                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16774                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16775                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16776                                 if (ndr->offset > ndr->relative_highest_offset) {
16777                                         ndr->relative_highest_offset = ndr->offset;
16778                                 }
16779                                 ndr->offset = _relative_save_offset;
16780                         }
16781                         ndr->flags = _flags_save_string;
16782                 }
16783         }
16784         return NDR_ERR_SUCCESS;
16785 }
16786
16787 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16788 {
16789         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16790         ndr->depth++;
16791         ndr_print_ptr(ndr, "port_name", r->port_name);
16792         ndr->depth++;
16793         if (r->port_name) {
16794                 ndr_print_string(ndr, "port_name", r->port_name);
16795         }
16796         ndr->depth--;
16797         ndr->depth--;
16798 }
16799
16800 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16801 {
16802         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16803 }
16804
16805 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16806 {
16807         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16808         return NDR_ERR_SUCCESS;
16809 }
16810
16811 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16812 {
16813         uint32_t v;
16814         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16815         *r = v;
16816         return NDR_ERR_SUCCESS;
16817 }
16818
16819 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16820 {
16821         ndr_print_uint32(ndr, name, r);
16822         ndr->depth++;
16823         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16824         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16825         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16827         ndr->depth--;
16828 }
16829
16830 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16831 {
16832         if (ndr_flags & NDR_SCALARS) {
16833                 NDR_CHECK(ndr_push_align(ndr, 5));
16834                 {
16835                         uint32_t _flags_save_string = ndr->flags;
16836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16837                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16838                         ndr->flags = _flags_save_string;
16839                 }
16840                 {
16841                         uint32_t _flags_save_string = ndr->flags;
16842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16844                         ndr->flags = _flags_save_string;
16845                 }
16846                 {
16847                         uint32_t _flags_save_string = ndr->flags;
16848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16849                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16850                         ndr->flags = _flags_save_string;
16851                 }
16852                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16854                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16855         }
16856         if (ndr_flags & NDR_BUFFERS) {
16857                 {
16858                         uint32_t _flags_save_string = ndr->flags;
16859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16860                         if (r->port_name) {
16861                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16862                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16863                         }
16864                         ndr->flags = _flags_save_string;
16865                 }
16866                 {
16867                         uint32_t _flags_save_string = ndr->flags;
16868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16869                         if (r->monitor_name) {
16870                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16871                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16872                         }
16873                         ndr->flags = _flags_save_string;
16874                 }
16875                 {
16876                         uint32_t _flags_save_string = ndr->flags;
16877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16878                         if (r->description) {
16879                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
16880                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16881                         }
16882                         ndr->flags = _flags_save_string;
16883                 }
16884         }
16885         return NDR_ERR_SUCCESS;
16886 }
16887
16888 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16889 {
16890         uint32_t _ptr_port_name;
16891         TALLOC_CTX *_mem_save_port_name_0;
16892         uint32_t _ptr_monitor_name;
16893         TALLOC_CTX *_mem_save_monitor_name_0;
16894         uint32_t _ptr_description;
16895         TALLOC_CTX *_mem_save_description_0;
16896         if (ndr_flags & NDR_SCALARS) {
16897                 NDR_CHECK(ndr_pull_align(ndr, 5));
16898                 {
16899                         uint32_t _flags_save_string = ndr->flags;
16900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16902                         if (_ptr_port_name) {
16903                                 NDR_PULL_ALLOC(ndr, r->port_name);
16904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16905                         } else {
16906                                 r->port_name = NULL;
16907                         }
16908                         ndr->flags = _flags_save_string;
16909                 }
16910                 {
16911                         uint32_t _flags_save_string = ndr->flags;
16912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16913                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16914                         if (_ptr_monitor_name) {
16915                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16916                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16917                         } else {
16918                                 r->monitor_name = NULL;
16919                         }
16920                         ndr->flags = _flags_save_string;
16921                 }
16922                 {
16923                         uint32_t _flags_save_string = ndr->flags;
16924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16925                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16926                         if (_ptr_description) {
16927                                 NDR_PULL_ALLOC(ndr, r->description);
16928                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16929                         } else {
16930                                 r->description = NULL;
16931                         }
16932                         ndr->flags = _flags_save_string;
16933                 }
16934                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16936                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16937         }
16938         if (ndr_flags & NDR_BUFFERS) {
16939                 {
16940                         uint32_t _flags_save_string = ndr->flags;
16941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16942                         if (r->port_name) {
16943                                 uint32_t _relative_save_offset;
16944                                 _relative_save_offset = ndr->offset;
16945                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16946                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16947                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16948                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16949                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16950                                 if (ndr->offset > ndr->relative_highest_offset) {
16951                                         ndr->relative_highest_offset = ndr->offset;
16952                                 }
16953                                 ndr->offset = _relative_save_offset;
16954                         }
16955                         ndr->flags = _flags_save_string;
16956                 }
16957                 {
16958                         uint32_t _flags_save_string = ndr->flags;
16959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16960                         if (r->monitor_name) {
16961                                 uint32_t _relative_save_offset;
16962                                 _relative_save_offset = ndr->offset;
16963                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16964                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16965                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16966                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16967                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16968                                 if (ndr->offset > ndr->relative_highest_offset) {
16969                                         ndr->relative_highest_offset = ndr->offset;
16970                                 }
16971                                 ndr->offset = _relative_save_offset;
16972                         }
16973                         ndr->flags = _flags_save_string;
16974                 }
16975                 {
16976                         uint32_t _flags_save_string = ndr->flags;
16977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16978                         if (r->description) {
16979                                 uint32_t _relative_save_offset;
16980                                 _relative_save_offset = ndr->offset;
16981                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
16982                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
16983                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
16984                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
16985                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
16986                                 if (ndr->offset > ndr->relative_highest_offset) {
16987                                         ndr->relative_highest_offset = ndr->offset;
16988                                 }
16989                                 ndr->offset = _relative_save_offset;
16990                         }
16991                         ndr->flags = _flags_save_string;
16992                 }
16993         }
16994         return NDR_ERR_SUCCESS;
16995 }
16996
16997 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
16998 {
16999         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17000         ndr->depth++;
17001         ndr_print_ptr(ndr, "port_name", r->port_name);
17002         ndr->depth++;
17003         if (r->port_name) {
17004                 ndr_print_string(ndr, "port_name", r->port_name);
17005         }
17006         ndr->depth--;
17007         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17008         ndr->depth++;
17009         if (r->monitor_name) {
17010                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17011         }
17012         ndr->depth--;
17013         ndr_print_ptr(ndr, "description", r->description);
17014         ndr->depth++;
17015         if (r->description) {
17016                 ndr_print_string(ndr, "description", r->description);
17017         }
17018         ndr->depth--;
17019         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17020         ndr_print_uint32(ndr, "reserved", r->reserved);
17021         ndr->depth--;
17022 }
17023
17024 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17025 {
17026         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17027 }
17028
17029 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17030 {
17031         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17032         return NDR_ERR_SUCCESS;
17033 }
17034
17035 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17036 {
17037         uint32_t v;
17038         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17039         *r = v;
17040         return NDR_ERR_SUCCESS;
17041 }
17042
17043 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17044 {
17045         const char *val = NULL;
17046
17047         switch (r) {
17048                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17049                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17050                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17051                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17052                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17053                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17054                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17055                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17056                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17057                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17058                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17059                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17060                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17061         }
17062         ndr_print_enum(ndr, name, "ENUM", val, r);
17063 }
17064
17065 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17066 {
17067         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17068         return NDR_ERR_SUCCESS;
17069 }
17070
17071 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17072 {
17073         uint32_t v;
17074         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17075         *r = v;
17076         return NDR_ERR_SUCCESS;
17077 }
17078
17079 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17080 {
17081         const char *val = NULL;
17082
17083         switch (r) {
17084                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17085                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17086                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17087         }
17088         ndr_print_enum(ndr, name, "ENUM", val, r);
17089 }
17090
17091 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17092 {
17093         if (ndr_flags & NDR_SCALARS) {
17094                 NDR_CHECK(ndr_push_align(ndr, 5));
17095                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17096                 {
17097                         uint32_t _flags_save_string = ndr->flags;
17098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17099                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17100                         ndr->flags = _flags_save_string;
17101                 }
17102                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17103                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17104         }
17105         if (ndr_flags & NDR_BUFFERS) {
17106                 {
17107                         uint32_t _flags_save_string = ndr->flags;
17108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17109                         if (r->status_string) {
17110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
17111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17112                         }
17113                         ndr->flags = _flags_save_string;
17114                 }
17115         }
17116         return NDR_ERR_SUCCESS;
17117 }
17118
17119 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17120 {
17121         uint32_t _ptr_status_string;
17122         TALLOC_CTX *_mem_save_status_string_0;
17123         if (ndr_flags & NDR_SCALARS) {
17124                 NDR_CHECK(ndr_pull_align(ndr, 5));
17125                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17126                 {
17127                         uint32_t _flags_save_string = ndr->flags;
17128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17129                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17130                         if (_ptr_status_string) {
17131                                 NDR_PULL_ALLOC(ndr, r->status_string);
17132                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17133                         } else {
17134                                 r->status_string = NULL;
17135                         }
17136                         ndr->flags = _flags_save_string;
17137                 }
17138                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17139                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17140         }
17141         if (ndr_flags & NDR_BUFFERS) {
17142                 {
17143                         uint32_t _flags_save_string = ndr->flags;
17144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17145                         if (r->status_string) {
17146                                 uint32_t _relative_save_offset;
17147                                 _relative_save_offset = ndr->offset;
17148                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17149                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17150                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17151                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17152                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17153                                 if (ndr->offset > ndr->relative_highest_offset) {
17154                                         ndr->relative_highest_offset = ndr->offset;
17155                                 }
17156                                 ndr->offset = _relative_save_offset;
17157                         }
17158                         ndr->flags = _flags_save_string;
17159                 }
17160         }
17161         return NDR_ERR_SUCCESS;
17162 }
17163
17164 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17165 {
17166         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17167         ndr->depth++;
17168         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17169         ndr_print_ptr(ndr, "status_string", r->status_string);
17170         ndr->depth++;
17171         if (r->status_string) {
17172                 ndr_print_string(ndr, "status_string", r->status_string);
17173         }
17174         ndr->depth--;
17175         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17176         ndr->depth--;
17177 }
17178
17179 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17180 {
17181         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17182 }
17183
17184 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17185 {
17186         if (ndr_flags & NDR_SCALARS) {
17187                 NDR_CHECK(ndr_push_align(ndr, 5));
17188                 {
17189                         uint32_t _flags_save_string = ndr->flags;
17190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17191                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17192                         ndr->flags = _flags_save_string;
17193                 }
17194                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17195                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17196         }
17197         if (ndr_flags & NDR_BUFFERS) {
17198                 {
17199                         uint32_t _flags_save_string = ndr->flags;
17200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17201                         if (r->port_name) {
17202                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
17203                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17204                         }
17205                         ndr->flags = _flags_save_string;
17206                 }
17207         }
17208         return NDR_ERR_SUCCESS;
17209 }
17210
17211 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17212 {
17213         uint32_t _ptr_port_name;
17214         TALLOC_CTX *_mem_save_port_name_0;
17215         if (ndr_flags & NDR_SCALARS) {
17216                 NDR_CHECK(ndr_pull_align(ndr, 5));
17217                 {
17218                         uint32_t _flags_save_string = ndr->flags;
17219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17220                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17221                         if (_ptr_port_name) {
17222                                 NDR_PULL_ALLOC(ndr, r->port_name);
17223                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17224                         } else {
17225                                 r->port_name = NULL;
17226                         }
17227                         ndr->flags = _flags_save_string;
17228                 }
17229                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17230                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17231         }
17232         if (ndr_flags & NDR_BUFFERS) {
17233                 {
17234                         uint32_t _flags_save_string = ndr->flags;
17235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17236                         if (r->port_name) {
17237                                 uint32_t _relative_save_offset;
17238                                 _relative_save_offset = ndr->offset;
17239                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17240                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17241                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17242                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17243                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17244                                 if (ndr->offset > ndr->relative_highest_offset) {
17245                                         ndr->relative_highest_offset = ndr->offset;
17246                                 }
17247                                 ndr->offset = _relative_save_offset;
17248                         }
17249                         ndr->flags = _flags_save_string;
17250                 }
17251         }
17252         return NDR_ERR_SUCCESS;
17253 }
17254
17255 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17256 {
17257         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17258         ndr->depth++;
17259         ndr_print_ptr(ndr, "port_name", r->port_name);
17260         ndr->depth++;
17261         if (r->port_name) {
17262                 ndr_print_string(ndr, "port_name", r->port_name);
17263         }
17264         ndr->depth--;
17265         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17266         ndr->depth--;
17267 }
17268
17269 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17270 {
17271         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17272 }
17273
17274 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17275 {
17276         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17277         if (ndr_flags & NDR_SCALARS) {
17278                 int level = ndr_push_get_switch_value(ndr, r);
17279                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17280                 switch (level) {
17281                         case 1: {
17282                                 NDR_CHECK(ndr_push_align(ndr, 5));
17283                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17284                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17285                         break; }
17286
17287                         case 2: {
17288                                 NDR_CHECK(ndr_push_align(ndr, 5));
17289                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17290                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17291                         break; }
17292
17293                         case 3: {
17294                                 NDR_CHECK(ndr_push_align(ndr, 5));
17295                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17296                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17297                         break; }
17298
17299                         case 0xff: {
17300                                 NDR_CHECK(ndr_push_align(ndr, 5));
17301                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17302                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17303                         break; }
17304
17305                         default: {
17306                         break; }
17307
17308                 }
17309         }
17310         if (ndr_flags & NDR_BUFFERS) {
17311                 int level = ndr_push_get_switch_value(ndr, r);
17312                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17313                 switch (level) {
17314                         case 1:
17315                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17316                         break;
17317
17318                         case 2:
17319                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17320                         break;
17321
17322                         case 3:
17323                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17324                         break;
17325
17326                         case 0xff:
17327                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17328                         break;
17329
17330                         default:
17331                         break;
17332
17333                 }
17334         }
17335         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17336         return NDR_ERR_SUCCESS;
17337 }
17338
17339 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17340 {
17341         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17342         int level;
17343         level = ndr_pull_get_switch_value(ndr, r);
17344         if (ndr_flags & NDR_SCALARS) {
17345                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17346                 switch (level) {
17347                         case 1: {
17348                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17349                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17350                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17351                         break; }
17352
17353                         case 2: {
17354                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17355                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17356                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17357                         break; }
17358
17359                         case 3: {
17360                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17361                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17362                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17363                         break; }
17364
17365                         case 0xff: {
17366                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17367                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17368                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17369                         break; }
17370
17371                         default: {
17372                         break; }
17373
17374                 }
17375         }
17376         if (ndr_flags & NDR_BUFFERS) {
17377                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17378                 switch (level) {
17379                         case 1:
17380                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17381                         break;
17382
17383                         case 2:
17384                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17385                         break;
17386
17387                         case 3:
17388                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17389                         break;
17390
17391                         case 0xff:
17392                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17393                         break;
17394
17395                         default:
17396                         break;
17397
17398                 }
17399         }
17400         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17401         return NDR_ERR_SUCCESS;
17402 }
17403
17404 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17405 {
17406         int level;
17407         level = ndr_print_get_switch_value(ndr, r);
17408         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17409         switch (level) {
17410                 case 1:
17411                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17412                 break;
17413
17414                 case 2:
17415                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17416                 break;
17417
17418                 case 3:
17419                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17420                 break;
17421
17422                 case 0xff:
17423                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17424                 break;
17425
17426                 default:
17427                 break;
17428
17429         }
17430 }
17431
17432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17433 {
17434         if (ndr_flags & NDR_SCALARS) {
17435                 NDR_CHECK(ndr_push_align(ndr, 5));
17436                 {
17437                         uint32_t _flags_save_string = ndr->flags;
17438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17440                         ndr->flags = _flags_save_string;
17441                 }
17442                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17443         }
17444         if (ndr_flags & NDR_BUFFERS) {
17445                 {
17446                         uint32_t _flags_save_string = ndr->flags;
17447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17448                         if (r->monitor_name) {
17449                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17450                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17451                         }
17452                         ndr->flags = _flags_save_string;
17453                 }
17454         }
17455         return NDR_ERR_SUCCESS;
17456 }
17457
17458 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17459 {
17460         uint32_t _ptr_monitor_name;
17461         TALLOC_CTX *_mem_save_monitor_name_0;
17462         if (ndr_flags & NDR_SCALARS) {
17463                 NDR_CHECK(ndr_pull_align(ndr, 5));
17464                 {
17465                         uint32_t _flags_save_string = ndr->flags;
17466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17467                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17468                         if (_ptr_monitor_name) {
17469                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17470                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17471                         } else {
17472                                 r->monitor_name = NULL;
17473                         }
17474                         ndr->flags = _flags_save_string;
17475                 }
17476                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17477         }
17478         if (ndr_flags & NDR_BUFFERS) {
17479                 {
17480                         uint32_t _flags_save_string = ndr->flags;
17481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17482                         if (r->monitor_name) {
17483                                 uint32_t _relative_save_offset;
17484                                 _relative_save_offset = ndr->offset;
17485                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17486                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17487                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17488                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17489                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17490                                 if (ndr->offset > ndr->relative_highest_offset) {
17491                                         ndr->relative_highest_offset = ndr->offset;
17492                                 }
17493                                 ndr->offset = _relative_save_offset;
17494                         }
17495                         ndr->flags = _flags_save_string;
17496                 }
17497         }
17498         return NDR_ERR_SUCCESS;
17499 }
17500
17501 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17502 {
17503         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17504         ndr->depth++;
17505         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17506         ndr->depth++;
17507         if (r->monitor_name) {
17508                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17509         }
17510         ndr->depth--;
17511         ndr->depth--;
17512 }
17513
17514 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17515 {
17516         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17517 }
17518
17519 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17520 {
17521         if (ndr_flags & NDR_SCALARS) {
17522                 NDR_CHECK(ndr_push_align(ndr, 5));
17523                 {
17524                         uint32_t _flags_save_string = ndr->flags;
17525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17526                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17527                         ndr->flags = _flags_save_string;
17528                 }
17529                 {
17530                         uint32_t _flags_save_string = ndr->flags;
17531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17533                         ndr->flags = _flags_save_string;
17534                 }
17535                 {
17536                         uint32_t _flags_save_string = ndr->flags;
17537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17539                         ndr->flags = _flags_save_string;
17540                 }
17541                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17542         }
17543         if (ndr_flags & NDR_BUFFERS) {
17544                 {
17545                         uint32_t _flags_save_string = ndr->flags;
17546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17547                         if (r->monitor_name) {
17548                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17549                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17550                         }
17551                         ndr->flags = _flags_save_string;
17552                 }
17553                 {
17554                         uint32_t _flags_save_string = ndr->flags;
17555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17556                         if (r->environment) {
17557                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17558                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17559                         }
17560                         ndr->flags = _flags_save_string;
17561                 }
17562                 {
17563                         uint32_t _flags_save_string = ndr->flags;
17564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17565                         if (r->dll_name) {
17566                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17567                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17568                         }
17569                         ndr->flags = _flags_save_string;
17570                 }
17571         }
17572         return NDR_ERR_SUCCESS;
17573 }
17574
17575 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17576 {
17577         uint32_t _ptr_monitor_name;
17578         TALLOC_CTX *_mem_save_monitor_name_0;
17579         uint32_t _ptr_environment;
17580         TALLOC_CTX *_mem_save_environment_0;
17581         uint32_t _ptr_dll_name;
17582         TALLOC_CTX *_mem_save_dll_name_0;
17583         if (ndr_flags & NDR_SCALARS) {
17584                 NDR_CHECK(ndr_pull_align(ndr, 5));
17585                 {
17586                         uint32_t _flags_save_string = ndr->flags;
17587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17588                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17589                         if (_ptr_monitor_name) {
17590                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17591                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17592                         } else {
17593                                 r->monitor_name = NULL;
17594                         }
17595                         ndr->flags = _flags_save_string;
17596                 }
17597                 {
17598                         uint32_t _flags_save_string = ndr->flags;
17599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17600                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17601                         if (_ptr_environment) {
17602                                 NDR_PULL_ALLOC(ndr, r->environment);
17603                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17604                         } else {
17605                                 r->environment = NULL;
17606                         }
17607                         ndr->flags = _flags_save_string;
17608                 }
17609                 {
17610                         uint32_t _flags_save_string = ndr->flags;
17611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17612                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17613                         if (_ptr_dll_name) {
17614                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17615                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17616                         } else {
17617                                 r->dll_name = NULL;
17618                         }
17619                         ndr->flags = _flags_save_string;
17620                 }
17621                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17622         }
17623         if (ndr_flags & NDR_BUFFERS) {
17624                 {
17625                         uint32_t _flags_save_string = ndr->flags;
17626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17627                         if (r->monitor_name) {
17628                                 uint32_t _relative_save_offset;
17629                                 _relative_save_offset = ndr->offset;
17630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17631                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17632                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17635                                 if (ndr->offset > ndr->relative_highest_offset) {
17636                                         ndr->relative_highest_offset = ndr->offset;
17637                                 }
17638                                 ndr->offset = _relative_save_offset;
17639                         }
17640                         ndr->flags = _flags_save_string;
17641                 }
17642                 {
17643                         uint32_t _flags_save_string = ndr->flags;
17644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17645                         if (r->environment) {
17646                                 uint32_t _relative_save_offset;
17647                                 _relative_save_offset = ndr->offset;
17648                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17649                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17650                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17651                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17652                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17653                                 if (ndr->offset > ndr->relative_highest_offset) {
17654                                         ndr->relative_highest_offset = ndr->offset;
17655                                 }
17656                                 ndr->offset = _relative_save_offset;
17657                         }
17658                         ndr->flags = _flags_save_string;
17659                 }
17660                 {
17661                         uint32_t _flags_save_string = ndr->flags;
17662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17663                         if (r->dll_name) {
17664                                 uint32_t _relative_save_offset;
17665                                 _relative_save_offset = ndr->offset;
17666                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17667                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17668                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17669                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17670                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17671                                 if (ndr->offset > ndr->relative_highest_offset) {
17672                                         ndr->relative_highest_offset = ndr->offset;
17673                                 }
17674                                 ndr->offset = _relative_save_offset;
17675                         }
17676                         ndr->flags = _flags_save_string;
17677                 }
17678         }
17679         return NDR_ERR_SUCCESS;
17680 }
17681
17682 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17683 {
17684         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17685         ndr->depth++;
17686         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17687         ndr->depth++;
17688         if (r->monitor_name) {
17689                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17690         }
17691         ndr->depth--;
17692         ndr_print_ptr(ndr, "environment", r->environment);
17693         ndr->depth++;
17694         if (r->environment) {
17695                 ndr_print_string(ndr, "environment", r->environment);
17696         }
17697         ndr->depth--;
17698         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17699         ndr->depth++;
17700         if (r->dll_name) {
17701                 ndr_print_string(ndr, "dll_name", r->dll_name);
17702         }
17703         ndr->depth--;
17704         ndr->depth--;
17705 }
17706
17707 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17708 {
17709         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17710 }
17711
17712 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17713 {
17714         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17715         if (ndr_flags & NDR_SCALARS) {
17716                 int level = ndr_push_get_switch_value(ndr, r);
17717                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17718                 switch (level) {
17719                         case 1: {
17720                                 NDR_CHECK(ndr_push_align(ndr, 5));
17721                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17722                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17723                         break; }
17724
17725                         case 2: {
17726                                 NDR_CHECK(ndr_push_align(ndr, 5));
17727                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17728                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17729                         break; }
17730
17731                         default: {
17732                         break; }
17733
17734                 }
17735         }
17736         if (ndr_flags & NDR_BUFFERS) {
17737                 int level = ndr_push_get_switch_value(ndr, r);
17738                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17739                 switch (level) {
17740                         case 1:
17741                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17742                         break;
17743
17744                         case 2:
17745                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17746                         break;
17747
17748                         default:
17749                         break;
17750
17751                 }
17752         }
17753         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17754         return NDR_ERR_SUCCESS;
17755 }
17756
17757 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17758 {
17759         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17760         int level;
17761         level = ndr_pull_get_switch_value(ndr, r);
17762         if (ndr_flags & NDR_SCALARS) {
17763                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17764                 switch (level) {
17765                         case 1: {
17766                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17767                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17768                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17769                         break; }
17770
17771                         case 2: {
17772                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17773                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17774                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17775                         break; }
17776
17777                         default: {
17778                         break; }
17779
17780                 }
17781         }
17782         if (ndr_flags & NDR_BUFFERS) {
17783                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17784                 switch (level) {
17785                         case 1:
17786                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17787                         break;
17788
17789                         case 2:
17790                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17791                         break;
17792
17793                         default:
17794                         break;
17795
17796                 }
17797         }
17798         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17799         return NDR_ERR_SUCCESS;
17800 }
17801
17802 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17803 {
17804         int level;
17805         level = ndr_print_get_switch_value(ndr, r);
17806         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17807         switch (level) {
17808                 case 1:
17809                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17810                 break;
17811
17812                 case 2:
17813                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17814                 break;
17815
17816                 default:
17817                 break;
17818
17819         }
17820 }
17821
17822 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17823 {
17824         if (ndr_flags & NDR_SCALARS) {
17825                 NDR_CHECK(ndr_push_align(ndr, 5));
17826                 {
17827                         uint32_t _flags_save_string = ndr->flags;
17828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17830                         ndr->flags = _flags_save_string;
17831                 }
17832                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17833         }
17834         if (ndr_flags & NDR_BUFFERS) {
17835                 {
17836                         uint32_t _flags_save_string = ndr->flags;
17837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17838                         if (r->name_array) {
17839                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
17840                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17841                         }
17842                         ndr->flags = _flags_save_string;
17843                 }
17844         }
17845         return NDR_ERR_SUCCESS;
17846 }
17847
17848 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17849 {
17850         uint32_t _ptr_name_array;
17851         TALLOC_CTX *_mem_save_name_array_0;
17852         if (ndr_flags & NDR_SCALARS) {
17853                 NDR_CHECK(ndr_pull_align(ndr, 5));
17854                 {
17855                         uint32_t _flags_save_string = ndr->flags;
17856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17857                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17858                         if (_ptr_name_array) {
17859                                 NDR_PULL_ALLOC(ndr, r->name_array);
17860                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17861                         } else {
17862                                 r->name_array = NULL;
17863                         }
17864                         ndr->flags = _flags_save_string;
17865                 }
17866                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17867         }
17868         if (ndr_flags & NDR_BUFFERS) {
17869                 {
17870                         uint32_t _flags_save_string = ndr->flags;
17871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17872                         if (r->name_array) {
17873                                 uint32_t _relative_save_offset;
17874                                 _relative_save_offset = ndr->offset;
17875                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17876                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17877                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17878                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17879                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17880                                 if (ndr->offset > ndr->relative_highest_offset) {
17881                                         ndr->relative_highest_offset = ndr->offset;
17882                                 }
17883                                 ndr->offset = _relative_save_offset;
17884                         }
17885                         ndr->flags = _flags_save_string;
17886                 }
17887         }
17888         return NDR_ERR_SUCCESS;
17889 }
17890
17891 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17892 {
17893         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17894         ndr->depth++;
17895         ndr_print_ptr(ndr, "name_array", r->name_array);
17896         ndr->depth++;
17897         if (r->name_array) {
17898                 ndr_print_string(ndr, "name_array", r->name_array);
17899         }
17900         ndr->depth--;
17901         ndr->depth--;
17902 }
17903
17904 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17905 {
17906         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17907 }
17908
17909 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17910 {
17911         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17912         if (ndr_flags & NDR_SCALARS) {
17913                 int level = ndr_push_get_switch_value(ndr, r);
17914                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17915                 switch (level) {
17916                         case 1: {
17917                                 NDR_CHECK(ndr_push_align(ndr, 5));
17918                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17919                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17920                         break; }
17921
17922                         default: {
17923                         break; }
17924
17925                 }
17926         }
17927         if (ndr_flags & NDR_BUFFERS) {
17928                 int level = ndr_push_get_switch_value(ndr, r);
17929                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17930                 switch (level) {
17931                         case 1:
17932                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17933                         break;
17934
17935                         default:
17936                         break;
17937
17938                 }
17939         }
17940         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17941         return NDR_ERR_SUCCESS;
17942 }
17943
17944 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17945 {
17946         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17947         int level;
17948         level = ndr_pull_get_switch_value(ndr, r);
17949         if (ndr_flags & NDR_SCALARS) {
17950                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17951                 switch (level) {
17952                         case 1: {
17953                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17954                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17955                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17956                         break; }
17957
17958                         default: {
17959                         break; }
17960
17961                 }
17962         }
17963         if (ndr_flags & NDR_BUFFERS) {
17964                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17965                 switch (level) {
17966                         case 1:
17967                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17968                         break;
17969
17970                         default:
17971                         break;
17972
17973                 }
17974         }
17975         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17976         return NDR_ERR_SUCCESS;
17977 }
17978
17979 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
17980 {
17981         int level;
17982         level = ndr_print_get_switch_value(ndr, r);
17983         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
17984         switch (level) {
17985                 case 1:
17986                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
17987                 break;
17988
17989                 default:
17990                 break;
17991
17992         }
17993 }
17994
17995 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17996 {
17997         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17998         return NDR_ERR_SUCCESS;
17999 }
18000
18001 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18002 {
18003         uint32_t v;
18004         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18005         *r = v;
18006         return NDR_ERR_SUCCESS;
18007 }
18008
18009 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18010 {
18011         ndr_print_uint32(ndr, name, r);
18012         ndr->depth++;
18013         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18014         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18015         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18016         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18017         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18018         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18019         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18020         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18021         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18022         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18023         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18024         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18025         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18026         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18027         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18028         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18029         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18030         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18031         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18032         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18033         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18034         ndr->depth--;
18035 }
18036
18037 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18038 {
18039         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18040         return NDR_ERR_SUCCESS;
18041 }
18042
18043 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18044 {
18045         uint16_t v;
18046         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18047         *r = v;
18048         return NDR_ERR_SUCCESS;
18049 }
18050
18051 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18052 {
18053         const char *val = NULL;
18054
18055         switch (r) {
18056                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18057                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18058                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18059                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18060                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18061                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18062                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18063                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18064                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18065                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18066                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18067                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18068                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18069                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18070                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18071                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18072                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18073                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18074                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18075                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18076                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18077                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18078                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18079                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18080         }
18081         ndr_print_enum(ndr, name, "ENUM", val, r);
18082 }
18083
18084 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18085 {
18086         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18087         return NDR_ERR_SUCCESS;
18088 }
18089
18090 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18091 {
18092         uint16_t v;
18093         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18094         *r = v;
18095         return NDR_ERR_SUCCESS;
18096 }
18097
18098 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18099 {
18100         const char *val = NULL;
18101
18102         switch (r) {
18103                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18104                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18105                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18106                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18107                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18108                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18109                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18110                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18111                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18112                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18113                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18114                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18115                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18116                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18117                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18118                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18119                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18120                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18121                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18122                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18123                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18124                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18125                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18126                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18127                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18128                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18129                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18130                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18131         }
18132         ndr_print_enum(ndr, name, "ENUM", val, r);
18133 }
18134
18135 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18136 {
18137         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18138         return NDR_ERR_SUCCESS;
18139 }
18140
18141 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18142 {
18143         uint16_t v;
18144         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18145         *r = v;
18146         return NDR_ERR_SUCCESS;
18147 }
18148
18149 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18150 {
18151         const char *val = NULL;
18152
18153         switch (r) {
18154                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18155                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18156         }
18157         ndr_print_enum(ndr, name, "ENUM", val, r);
18158 }
18159
18160 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18161 {
18162         if (ndr_flags & NDR_SCALARS) {
18163                 int level = ndr_push_get_switch_value(ndr, r);
18164                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18165                 switch (level) {
18166                         case PRINTER_NOTIFY_TYPE: {
18167                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18168                         break; }
18169
18170                         case JOB_NOTIFY_TYPE: {
18171                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18172                         break; }
18173
18174                         default: {
18175                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18176                         break; }
18177
18178                 }
18179         }
18180         if (ndr_flags & NDR_BUFFERS) {
18181                 int level = ndr_push_get_switch_value(ndr, r);
18182                 switch (level) {
18183                         case PRINTER_NOTIFY_TYPE:
18184                         break;
18185
18186                         case JOB_NOTIFY_TYPE:
18187                         break;
18188
18189                         default:
18190                         break;
18191
18192                 }
18193         }
18194         return NDR_ERR_SUCCESS;
18195 }
18196
18197 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18198 {
18199         int level;
18200         level = ndr_pull_get_switch_value(ndr, r);
18201         if (ndr_flags & NDR_SCALARS) {
18202                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18203                 switch (level) {
18204                         case PRINTER_NOTIFY_TYPE: {
18205                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18206                         break; }
18207
18208                         case JOB_NOTIFY_TYPE: {
18209                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18210                         break; }
18211
18212                         default: {
18213                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18214                         break; }
18215
18216                 }
18217         }
18218         if (ndr_flags & NDR_BUFFERS) {
18219                 switch (level) {
18220                         case PRINTER_NOTIFY_TYPE:
18221                         break;
18222
18223                         case JOB_NOTIFY_TYPE:
18224                         break;
18225
18226                         default:
18227                         break;
18228
18229                 }
18230         }
18231         return NDR_ERR_SUCCESS;
18232 }
18233
18234 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18235 {
18236         uint32_t cntr_fields_1;
18237         if (ndr_flags & NDR_SCALARS) {
18238                 NDR_CHECK(ndr_push_align(ndr, 5));
18239                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18240                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18245                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18246         }
18247         if (ndr_flags & NDR_BUFFERS) {
18248                 if (r->fields) {
18249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18250                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18251                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18252                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18253                         }
18254                 }
18255         }
18256         return NDR_ERR_SUCCESS;
18257 }
18258
18259 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18260 {
18261         uint32_t _ptr_fields;
18262         uint32_t cntr_fields_1;
18263         TALLOC_CTX *_mem_save_fields_0;
18264         TALLOC_CTX *_mem_save_fields_1;
18265         if (ndr_flags & NDR_SCALARS) {
18266                 NDR_CHECK(ndr_pull_align(ndr, 5));
18267                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18268                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18273                 if (_ptr_fields) {
18274                         NDR_PULL_ALLOC(ndr, r->fields);
18275                 } else {
18276                         r->fields = NULL;
18277                 }
18278                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18279         }
18280         if (ndr_flags & NDR_BUFFERS) {
18281                 if (r->fields) {
18282                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18283                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18285                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18286                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18287                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18288                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18289                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18290                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18291                         }
18292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18294                 }
18295                 if (r->fields) {
18296                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18297                 }
18298         }
18299         return NDR_ERR_SUCCESS;
18300 }
18301
18302 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18303 {
18304         uint32_t cntr_fields_1;
18305         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18306         ndr->depth++;
18307         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18308         ndr_print_uint16(ndr, "u1", r->u1);
18309         ndr_print_uint32(ndr, "u2", r->u2);
18310         ndr_print_uint32(ndr, "u3", r->u3);
18311         ndr_print_uint32(ndr, "count", r->count);
18312         ndr_print_ptr(ndr, "fields", r->fields);
18313         ndr->depth++;
18314         if (r->fields) {
18315                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18316                 ndr->depth++;
18317                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18318                         char *idx_1=NULL;
18319                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18320                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18321                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18322                                 free(idx_1);
18323                         }
18324                 }
18325                 ndr->depth--;
18326         }
18327         ndr->depth--;
18328         ndr->depth--;
18329 }
18330
18331 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18332 {
18333         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18334         return NDR_ERR_SUCCESS;
18335 }
18336
18337 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18338 {
18339         uint32_t v;
18340         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18341         *r = v;
18342         return NDR_ERR_SUCCESS;
18343 }
18344
18345 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18346 {
18347         ndr_print_uint32(ndr, name, r);
18348         ndr->depth++;
18349         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18350         ndr->depth--;
18351 }
18352
18353 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18354 {
18355         uint32_t cntr_types_1;
18356         if (ndr_flags & NDR_SCALARS) {
18357                 NDR_CHECK(ndr_push_align(ndr, 5));
18358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18359                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18362                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18363         }
18364         if (ndr_flags & NDR_BUFFERS) {
18365                 if (r->types) {
18366                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18367                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18368                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18369                         }
18370                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18371                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18372                         }
18373                 }
18374         }
18375         return NDR_ERR_SUCCESS;
18376 }
18377
18378 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18379 {
18380         uint32_t _ptr_types;
18381         uint32_t cntr_types_1;
18382         TALLOC_CTX *_mem_save_types_0;
18383         TALLOC_CTX *_mem_save_types_1;
18384         if (ndr_flags & NDR_SCALARS) {
18385                 NDR_CHECK(ndr_pull_align(ndr, 5));
18386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18387                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18390                 if (_ptr_types) {
18391                         NDR_PULL_ALLOC(ndr, r->types);
18392                 } else {
18393                         r->types = NULL;
18394                 }
18395                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18396         }
18397         if (ndr_flags & NDR_BUFFERS) {
18398                 if (r->types) {
18399                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18400                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18402                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18403                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18404                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18405                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18406                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18407                         }
18408                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18409                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18410                         }
18411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18412                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18413                 }
18414                 if (r->types) {
18415                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18416                 }
18417         }
18418         return NDR_ERR_SUCCESS;
18419 }
18420
18421 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18422 {
18423         uint32_t cntr_types_1;
18424         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18425         ndr->depth++;
18426         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18427         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18428         ndr_print_uint32(ndr, "count", r->count);
18429         ndr_print_ptr(ndr, "types", r->types);
18430         ndr->depth++;
18431         if (r->types) {
18432                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18433                 ndr->depth++;
18434                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18435                         char *idx_1=NULL;
18436                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18437                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18438                                 free(idx_1);
18439                         }
18440                 }
18441                 ndr->depth--;
18442         }
18443         ndr->depth--;
18444         ndr->depth--;
18445 }
18446
18447 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18448 {
18449         if (ndr_flags & NDR_SCALARS) {
18450                 NDR_CHECK(ndr_push_align(ndr, 5));
18451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18453                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18454         }
18455         if (ndr_flags & NDR_BUFFERS) {
18456                 if (r->string) {
18457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18459                 }
18460         }
18461         return NDR_ERR_SUCCESS;
18462 }
18463
18464 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18465 {
18466         uint32_t _ptr_string;
18467         TALLOC_CTX *_mem_save_string_0;
18468         if (ndr_flags & NDR_SCALARS) {
18469                 NDR_CHECK(ndr_pull_align(ndr, 5));
18470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18472                 if (_ptr_string) {
18473                         NDR_PULL_ALLOC(ndr, r->string);
18474                 } else {
18475                         r->string = NULL;
18476                 }
18477                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18478         }
18479         if (ndr_flags & NDR_BUFFERS) {
18480                 if (r->string) {
18481                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18482                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18483                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18484                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18486                 }
18487                 if (r->string) {
18488                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18489                 }
18490         }
18491         return NDR_ERR_SUCCESS;
18492 }
18493
18494 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18495 {
18496         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18497         ndr->depth++;
18498         ndr_print_uint32(ndr, "size", r->size);
18499         ndr_print_ptr(ndr, "string", r->string);
18500         ndr->depth++;
18501         if (r->string) {
18502                 ndr_print_string(ndr, "string", r->string);
18503         }
18504         ndr->depth--;
18505         ndr->depth--;
18506 }
18507
18508 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18509 {
18510         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18511         return NDR_ERR_SUCCESS;
18512 }
18513
18514 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18515 {
18516         uint32_t v;
18517         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18518         *r = v;
18519         return NDR_ERR_SUCCESS;
18520 }
18521
18522 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18523 {
18524         const char *val = NULL;
18525
18526         switch (r) {
18527                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18528                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18529                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18530                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18531                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18532         }
18533         ndr_print_enum(ndr, name, "ENUM", val, r);
18534 }
18535
18536 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18537 {
18538         if (ndr_flags & NDR_SCALARS) {
18539                 int level = ndr_push_get_switch_value(ndr, r);
18540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18541                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18542                 switch (level) {
18543                         case 1: {
18544                                 uint32_t cntr_integer_0;
18545                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18546                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18547                                 }
18548                         break; }
18549
18550                         case 2: {
18551                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18552                         break; }
18553
18554                         case 3: {
18555                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18556                         break; }
18557
18558                         case 4: {
18559                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18560                         break; }
18561
18562                         case 5: {
18563                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18564                         break; }
18565
18566                         default:
18567                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18568                 }
18569         }
18570         if (ndr_flags & NDR_BUFFERS) {
18571                 int level = ndr_push_get_switch_value(ndr, r);
18572                 switch (level) {
18573                         case 1:
18574                         break;
18575
18576                         case 2:
18577                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18578                         break;
18579
18580                         case 3:
18581                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18582                         break;
18583
18584                         case 4:
18585                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18586                         break;
18587
18588                         case 5:
18589                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18590                         break;
18591
18592                         default:
18593                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18594                 }
18595         }
18596         return NDR_ERR_SUCCESS;
18597 }
18598
18599 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18600 {
18601         int level;
18602         uint32_t _level;
18603         level = ndr_pull_get_switch_value(ndr, r);
18604         if (ndr_flags & NDR_SCALARS) {
18605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18606                 if (_level != level) {
18607                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18608                 }
18609                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18610                 switch (level) {
18611                         case 1: {
18612                                 uint32_t cntr_integer_0;
18613                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18614                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18615                                 }
18616                         break; }
18617
18618                         case 2: {
18619                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18620                         break; }
18621
18622                         case 3: {
18623                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18624                         break; }
18625
18626                         case 4: {
18627                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18628                         break; }
18629
18630                         case 5: {
18631                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18632                         break; }
18633
18634                         default:
18635                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18636                 }
18637         }
18638         if (ndr_flags & NDR_BUFFERS) {
18639                 switch (level) {
18640                         case 1:
18641                         break;
18642
18643                         case 2:
18644                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18645                         break;
18646
18647                         case 3:
18648                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18649                         break;
18650
18651                         case 4:
18652                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18653                         break;
18654
18655                         case 5:
18656                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18657                         break;
18658
18659                         default:
18660                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18661                 }
18662         }
18663         return NDR_ERR_SUCCESS;
18664 }
18665
18666 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18667 {
18668         int level;
18669         uint32_t cntr_integer_0;
18670         level = ndr_print_get_switch_value(ndr, r);
18671         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18672         switch (level) {
18673                 case 1:
18674                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18675                         ndr->depth++;
18676                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18677                                 char *idx_0=NULL;
18678                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18679                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18680                                         free(idx_0);
18681                                 }
18682                         }
18683                         ndr->depth--;
18684                 break;
18685
18686                 case 2:
18687                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18688                 break;
18689
18690                 case 3:
18691                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18692                 break;
18693
18694                 case 4:
18695                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18696                 break;
18697
18698                 case 5:
18699                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18700                 break;
18701
18702                 default:
18703                         ndr_print_bad_level(ndr, name, level);
18704         }
18705 }
18706
18707 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18708 {
18709         if (ndr_flags & NDR_SCALARS) {
18710                 NDR_CHECK(ndr_push_align(ndr, 5));
18711                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18712                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18713                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18714                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18716                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18717                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18718                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18719         }
18720         if (ndr_flags & NDR_BUFFERS) {
18721                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18722         }
18723         return NDR_ERR_SUCCESS;
18724 }
18725
18726 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18727 {
18728         if (ndr_flags & NDR_SCALARS) {
18729                 NDR_CHECK(ndr_pull_align(ndr, 5));
18730                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18731                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18732                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18733                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18735                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18736                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18737                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18738         }
18739         if (ndr_flags & NDR_BUFFERS) {
18740                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18741         }
18742         return NDR_ERR_SUCCESS;
18743 }
18744
18745 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18746 {
18747         ndr_print_struct(ndr, name, "spoolss_Notify");
18748         ndr->depth++;
18749         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18750         ndr_print_set_switch_value(ndr, &r->field, r->type);
18751         ndr_print_spoolss_Field(ndr, "field", &r->field);
18752         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18753         ndr_print_uint32(ndr, "job_id", r->job_id);
18754         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18755         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18756         ndr->depth--;
18757 }
18758
18759 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18760 {
18761         uint32_t cntr_notifies_0;
18762         if (ndr_flags & NDR_SCALARS) {
18763                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18764                 NDR_CHECK(ndr_push_align(ndr, 5));
18765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18768                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18769                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18770                 }
18771                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18772         }
18773         if (ndr_flags & NDR_BUFFERS) {
18774                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18775                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18776                 }
18777         }
18778         return NDR_ERR_SUCCESS;
18779 }
18780
18781 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18782 {
18783         uint32_t cntr_notifies_0;
18784         TALLOC_CTX *_mem_save_notifies_0;
18785         if (ndr_flags & NDR_SCALARS) {
18786                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18787                 NDR_CHECK(ndr_pull_align(ndr, 5));
18788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18791                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18792                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18793                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18794                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18795                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18796                 }
18797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18798                 if (r->notifies) {
18799                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18800                 }
18801                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18802         }
18803         if (ndr_flags & NDR_BUFFERS) {
18804                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18805                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18806                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18807                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18808                 }
18809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18810         }
18811         return NDR_ERR_SUCCESS;
18812 }
18813
18814 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18815 {
18816         uint32_t cntr_notifies_0;
18817         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18818         ndr->depth++;
18819         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18820         ndr_print_uint32(ndr, "flags", r->flags);
18821         ndr_print_uint32(ndr, "count", r->count);
18822         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18823         ndr->depth++;
18824         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18825                 char *idx_0=NULL;
18826                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18827                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18828                         free(idx_0);
18829                 }
18830         }
18831         ndr->depth--;
18832         ndr->depth--;
18833 }
18834
18835 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18836 {
18837         if (ndr_flags & NDR_SCALARS) {
18838                 int level = ndr_push_get_switch_value(ndr, r);
18839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18840                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18841                 switch (level) {
18842                         case 0: {
18843                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18844                         break; }
18845
18846                         default:
18847                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18848                 }
18849         }
18850         if (ndr_flags & NDR_BUFFERS) {
18851                 int level = ndr_push_get_switch_value(ndr, r);
18852                 switch (level) {
18853                         case 0:
18854                                 if (r->info0) {
18855                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18856                                 }
18857                         break;
18858
18859                         default:
18860                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18861                 }
18862         }
18863         return NDR_ERR_SUCCESS;
18864 }
18865
18866 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18867 {
18868         int level;
18869         uint32_t _level;
18870         TALLOC_CTX *_mem_save_info0_0;
18871         level = ndr_pull_get_switch_value(ndr, r);
18872         if (ndr_flags & NDR_SCALARS) {
18873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18874                 if (_level != level) {
18875                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18876                 }
18877                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18878                 switch (level) {
18879                         case 0: {
18880                                 uint32_t _ptr_info0;
18881                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18882                                 if (_ptr_info0) {
18883                                         NDR_PULL_ALLOC(ndr, r->info0);
18884                                 } else {
18885                                         r->info0 = NULL;
18886                                 }
18887                         break; }
18888
18889                         default:
18890                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18891                 }
18892         }
18893         if (ndr_flags & NDR_BUFFERS) {
18894                 switch (level) {
18895                         case 0:
18896                                 if (r->info0) {
18897                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18898                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18899                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18900                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18901                                 }
18902                         break;
18903
18904                         default:
18905                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18906                 }
18907         }
18908         return NDR_ERR_SUCCESS;
18909 }
18910
18911 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18912 {
18913         int level;
18914         level = ndr_print_get_switch_value(ndr, r);
18915         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18916         switch (level) {
18917                 case 0:
18918                         ndr_print_ptr(ndr, "info0", r->info0);
18919                         ndr->depth++;
18920                         if (r->info0) {
18921                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18922                         }
18923                         ndr->depth--;
18924                 break;
18925
18926                 default:
18927                         ndr_print_bad_level(ndr, name, level);
18928         }
18929 }
18930
18931 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18932 {
18933         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18934         return NDR_ERR_SUCCESS;
18935 }
18936
18937 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18938 {
18939         uint32_t v;
18940         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18941         *r = v;
18942         return NDR_ERR_SUCCESS;
18943 }
18944
18945 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18946 {
18947         ndr_print_uint32(ndr, name, r);
18948         ndr->depth++;
18949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18950         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
18951         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
18952         ndr->depth--;
18953 }
18954
18955 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
18956 {
18957         if (ndr_flags & NDR_SCALARS) {
18958                 NDR_CHECK(ndr_push_align(ndr, 5));
18959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18963                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18964                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18965                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18966                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18967         }
18968         if (ndr_flags & NDR_BUFFERS) {
18969                 if (r->client) {
18970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18973                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18974                 }
18975                 if (r->user) {
18976                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18979                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18980                 }
18981         }
18982         return NDR_ERR_SUCCESS;
18983 }
18984
18985 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
18986 {
18987         uint32_t _ptr_client;
18988         TALLOC_CTX *_mem_save_client_0;
18989         uint32_t _ptr_user;
18990         TALLOC_CTX *_mem_save_user_0;
18991         if (ndr_flags & NDR_SCALARS) {
18992                 NDR_CHECK(ndr_pull_align(ndr, 5));
18993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18995                 if (_ptr_client) {
18996                         NDR_PULL_ALLOC(ndr, r->client);
18997                 } else {
18998                         r->client = NULL;
18999                 }
19000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19001                 if (_ptr_user) {
19002                         NDR_PULL_ALLOC(ndr, r->user);
19003                 } else {
19004                         r->user = NULL;
19005                 }
19006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19007                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19008                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19009                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19010                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19011         }
19012         if (ndr_flags & NDR_BUFFERS) {
19013                 if (r->client) {
19014                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19015                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19018                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19019                                 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));
19020                         }
19021                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19022                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19024                 }
19025                 if (r->user) {
19026                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19027                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19028                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19029                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19030                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19031                                 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));
19032                         }
19033                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19034                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19036                 }
19037         }
19038         return NDR_ERR_SUCCESS;
19039 }
19040
19041 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19042 {
19043         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19044         ndr->depth++;
19045         ndr_print_uint32(ndr, "size", r->size);
19046         ndr_print_ptr(ndr, "client", r->client);
19047         ndr->depth++;
19048         if (r->client) {
19049                 ndr_print_string(ndr, "client", r->client);
19050         }
19051         ndr->depth--;
19052         ndr_print_ptr(ndr, "user", r->user);
19053         ndr->depth++;
19054         if (r->user) {
19055                 ndr_print_string(ndr, "user", r->user);
19056         }
19057         ndr->depth--;
19058         ndr_print_uint32(ndr, "build", r->build);
19059         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19060         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19061         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19062         ndr->depth--;
19063 }
19064
19065 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19066 {
19067         if (ndr_flags & NDR_SCALARS) {
19068                 NDR_CHECK(ndr_push_align(ndr, 4));
19069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19070                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19071         }
19072         if (ndr_flags & NDR_BUFFERS) {
19073         }
19074         return NDR_ERR_SUCCESS;
19075 }
19076
19077 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19078 {
19079         if (ndr_flags & NDR_SCALARS) {
19080                 NDR_CHECK(ndr_pull_align(ndr, 4));
19081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19082                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19083         }
19084         if (ndr_flags & NDR_BUFFERS) {
19085         }
19086         return NDR_ERR_SUCCESS;
19087 }
19088
19089 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19090 {
19091         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19092         ndr->depth++;
19093         ndr_print_uint32(ndr, "not_used", r->not_used);
19094         ndr->depth--;
19095 }
19096
19097 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19098 {
19099         if (ndr_flags & NDR_SCALARS) {
19100                 NDR_CHECK(ndr_push_align(ndr, 5));
19101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19104                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19105                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19107                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19108                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19109                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19110                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19111                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19112         }
19113         if (ndr_flags & NDR_BUFFERS) {
19114                 if (r->client) {
19115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19116                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19117                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19118                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19119                 }
19120                 if (r->user) {
19121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19122                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19123                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19125                 }
19126         }
19127         return NDR_ERR_SUCCESS;
19128 }
19129
19130 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19131 {
19132         uint32_t _ptr_client;
19133         TALLOC_CTX *_mem_save_client_0;
19134         uint32_t _ptr_user;
19135         TALLOC_CTX *_mem_save_user_0;
19136         if (ndr_flags & NDR_SCALARS) {
19137                 NDR_CHECK(ndr_pull_align(ndr, 5));
19138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19142                 if (_ptr_client) {
19143                         NDR_PULL_ALLOC(ndr, r->client);
19144                 } else {
19145                         r->client = NULL;
19146                 }
19147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19148                 if (_ptr_user) {
19149                         NDR_PULL_ALLOC(ndr, r->user);
19150                 } else {
19151                         r->user = NULL;
19152                 }
19153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19154                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19155                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19156                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19157                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19158                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19159         }
19160         if (ndr_flags & NDR_BUFFERS) {
19161                 if (r->client) {
19162                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19163                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19166                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19167                                 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));
19168                         }
19169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19172                 }
19173                 if (r->user) {
19174                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19175                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19178                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19179                                 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));
19180                         }
19181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19184                 }
19185         }
19186         return NDR_ERR_SUCCESS;
19187 }
19188
19189 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19190 {
19191         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19192         ndr->depth++;
19193         ndr_print_uint32(ndr, "size", r->size);
19194         ndr_print_uint32(ndr, "flags", r->flags);
19195         ndr_print_uint32(ndr, "size2", r->size2);
19196         ndr_print_ptr(ndr, "client", r->client);
19197         ndr->depth++;
19198         if (r->client) {
19199                 ndr_print_string(ndr, "client", r->client);
19200         }
19201         ndr->depth--;
19202         ndr_print_ptr(ndr, "user", r->user);
19203         ndr->depth++;
19204         if (r->user) {
19205                 ndr_print_string(ndr, "user", r->user);
19206         }
19207         ndr->depth--;
19208         ndr_print_uint32(ndr, "build", r->build);
19209         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19210         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19211         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19212         ndr_print_udlong(ndr, "reserved", r->reserved);
19213         ndr->depth--;
19214 }
19215
19216 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19217 {
19218         if (ndr_flags & NDR_SCALARS) {
19219                 int level = ndr_push_get_switch_value(ndr, r);
19220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19221                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19222                 switch (level) {
19223                         case 1: {
19224                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19225                         break; }
19226
19227                         case 2: {
19228                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19229                         break; }
19230
19231                         case 3: {
19232                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19233                         break; }
19234
19235                         default:
19236                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19237                 }
19238         }
19239         if (ndr_flags & NDR_BUFFERS) {
19240                 int level = ndr_push_get_switch_value(ndr, r);
19241                 switch (level) {
19242                         case 1:
19243                                 if (r->level1) {
19244                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19245                                 }
19246                         break;
19247
19248                         case 2:
19249                                 if (r->level2) {
19250                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19251                                 }
19252                         break;
19253
19254                         case 3:
19255                                 if (r->level3) {
19256                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19257                                 }
19258                         break;
19259
19260                         default:
19261                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19262                 }
19263         }
19264         return NDR_ERR_SUCCESS;
19265 }
19266
19267 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19268 {
19269         int level;
19270         uint32_t _level;
19271         TALLOC_CTX *_mem_save_level1_0;
19272         TALLOC_CTX *_mem_save_level2_0;
19273         TALLOC_CTX *_mem_save_level3_0;
19274         level = ndr_pull_get_switch_value(ndr, r);
19275         if (ndr_flags & NDR_SCALARS) {
19276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19277                 if (_level != level) {
19278                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19279                 }
19280                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19281                 switch (level) {
19282                         case 1: {
19283                                 uint32_t _ptr_level1;
19284                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19285                                 if (_ptr_level1) {
19286                                         NDR_PULL_ALLOC(ndr, r->level1);
19287                                 } else {
19288                                         r->level1 = NULL;
19289                                 }
19290                         break; }
19291
19292                         case 2: {
19293                                 uint32_t _ptr_level2;
19294                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19295                                 if (_ptr_level2) {
19296                                         NDR_PULL_ALLOC(ndr, r->level2);
19297                                 } else {
19298                                         r->level2 = NULL;
19299                                 }
19300                         break; }
19301
19302                         case 3: {
19303                                 uint32_t _ptr_level3;
19304                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19305                                 if (_ptr_level3) {
19306                                         NDR_PULL_ALLOC(ndr, r->level3);
19307                                 } else {
19308                                         r->level3 = NULL;
19309                                 }
19310                         break; }
19311
19312                         default:
19313                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19314                 }
19315         }
19316         if (ndr_flags & NDR_BUFFERS) {
19317                 switch (level) {
19318                         case 1:
19319                                 if (r->level1) {
19320                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19321                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19322                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19323                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19324                                 }
19325                         break;
19326
19327                         case 2:
19328                                 if (r->level2) {
19329                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19330                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19331                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19332                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19333                                 }
19334                         break;
19335
19336                         case 3:
19337                                 if (r->level3) {
19338                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19339                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19340                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19341                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19342                                 }
19343                         break;
19344
19345                         default:
19346                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19347                 }
19348         }
19349         return NDR_ERR_SUCCESS;
19350 }
19351
19352 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19353 {
19354         int level;
19355         level = ndr_print_get_switch_value(ndr, r);
19356         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19357         switch (level) {
19358                 case 1:
19359                         ndr_print_ptr(ndr, "level1", r->level1);
19360                         ndr->depth++;
19361                         if (r->level1) {
19362                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19363                         }
19364                         ndr->depth--;
19365                 break;
19366
19367                 case 2:
19368                         ndr_print_ptr(ndr, "level2", r->level2);
19369                         ndr->depth++;
19370                         if (r->level2) {
19371                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19372                         }
19373                         ndr->depth--;
19374                 break;
19375
19376                 case 3:
19377                         ndr_print_ptr(ndr, "level3", r->level3);
19378                         ndr->depth++;
19379                         if (r->level3) {
19380                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19381                         }
19382                         ndr->depth--;
19383                 break;
19384
19385                 default:
19386                         ndr_print_bad_level(ndr, name, level);
19387         }
19388 }
19389
19390 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19391 {
19392         if (ndr_flags & NDR_SCALARS) {
19393                 NDR_CHECK(ndr_push_align(ndr, 5));
19394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19395                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19396                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19397                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19398         }
19399         if (ndr_flags & NDR_BUFFERS) {
19400                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19401         }
19402         return NDR_ERR_SUCCESS;
19403 }
19404
19405 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19406 {
19407         if (ndr_flags & NDR_SCALARS) {
19408                 NDR_CHECK(ndr_pull_align(ndr, 5));
19409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19410                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19411                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19412                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19413         }
19414         if (ndr_flags & NDR_BUFFERS) {
19415                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19416         }
19417         return NDR_ERR_SUCCESS;
19418 }
19419
19420 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19421 {
19422         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19423         ndr->depth++;
19424         ndr_print_uint32(ndr, "level", r->level);
19425         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19426         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19427         ndr->depth--;
19428 }
19429
19430 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19431 {
19432         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19433         return NDR_ERR_SUCCESS;
19434 }
19435
19436 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19437 {
19438         uint32_t v;
19439         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19440         *r = v;
19441         return NDR_ERR_SUCCESS;
19442 }
19443
19444 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19445 {
19446         ndr_print_uint32(ndr, name, r);
19447         ndr->depth++;
19448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19452         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19454         ndr->depth--;
19455 }
19456
19457 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19458 {
19459         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19460         if (ndr_flags & NDR_SCALARS) {
19461                 NDR_CHECK(ndr_push_align(ndr, 5));
19462                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19463                 {
19464                         uint32_t _flags_save_string = ndr->flags;
19465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19466                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19467                         ndr->flags = _flags_save_string;
19468                 }
19469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19470                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19471                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19473                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19474         }
19475         if (ndr_flags & NDR_BUFFERS) {
19476                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19477                 {
19478                         uint32_t _flags_save_string = ndr->flags;
19479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19480                         if (r->value_name) {
19481                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
19482                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19483                         }
19484                         ndr->flags = _flags_save_string;
19485                 }
19486                 if (r->data) {
19487                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
19488                         {
19489                                 struct ndr_push *_ndr_data;
19490                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19491                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19492                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19493                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19494                         }
19495                 }
19496         }
19497         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19498         return NDR_ERR_SUCCESS;
19499 }
19500
19501 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19502 {
19503         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19504         uint32_t _ptr_value_name;
19505         TALLOC_CTX *_mem_save_value_name_0;
19506         uint32_t _ptr_data;
19507         TALLOC_CTX *_mem_save_data_0;
19508         if (ndr_flags & NDR_SCALARS) {
19509                 NDR_CHECK(ndr_pull_align(ndr, 5));
19510                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19511                 {
19512                         uint32_t _flags_save_string = ndr->flags;
19513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19514                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19515                         if (_ptr_value_name) {
19516                                 NDR_PULL_ALLOC(ndr, r->value_name);
19517                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19518                         } else {
19519                                 r->value_name = NULL;
19520                         }
19521                         ndr->flags = _flags_save_string;
19522                 }
19523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19524                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19525                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19526                 if (_ptr_data) {
19527                         NDR_PULL_ALLOC(ndr, r->data);
19528                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19529                 } else {
19530                         r->data = NULL;
19531                 }
19532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19533                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19534         }
19535         if (ndr_flags & NDR_BUFFERS) {
19536                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19537                 {
19538                         uint32_t _flags_save_string = ndr->flags;
19539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19540                         if (r->value_name) {
19541                                 uint32_t _relative_save_offset;
19542                                 _relative_save_offset = ndr->offset;
19543                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19544                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19545                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19546                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19547                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19548                                 if (ndr->offset > ndr->relative_highest_offset) {
19549                                         ndr->relative_highest_offset = ndr->offset;
19550                                 }
19551                                 ndr->offset = _relative_save_offset;
19552                         }
19553                         ndr->flags = _flags_save_string;
19554                 }
19555                 if (r->data) {
19556                         uint32_t _relative_save_offset;
19557                         _relative_save_offset = ndr->offset;
19558                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19559                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19560                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19561                         {
19562                                 struct ndr_pull *_ndr_data;
19563                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19564                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19565                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19566                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19567                         }
19568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19569                         if (ndr->offset > ndr->relative_highest_offset) {
19570                                 ndr->relative_highest_offset = ndr->offset;
19571                         }
19572                         ndr->offset = _relative_save_offset;
19573                 }
19574         }
19575         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19576         return NDR_ERR_SUCCESS;
19577 }
19578
19579 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19580 {
19581         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19582         ndr->depth++;
19583         ndr_print_ptr(ndr, "value_name", r->value_name);
19584         ndr->depth++;
19585         if (r->value_name) {
19586                 ndr_print_string(ndr, "value_name", r->value_name);
19587         }
19588         ndr->depth--;
19589         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19590         ndr_print_winreg_Type(ndr, "type", r->type);
19591         ndr_print_ptr(ndr, "data", r->data);
19592         ndr->depth++;
19593         if (r->data) {
19594                 ndr_print_set_switch_value(ndr, r->data, r->type);
19595                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19596         }
19597         ndr->depth--;
19598         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);
19599         ndr->depth--;
19600 }
19601
19602 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19603 {
19604         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19605 }
19606
19607 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19608 {
19609         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19610         return NDR_ERR_SUCCESS;
19611 }
19612
19613 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19614 {
19615         uint32_t v;
19616         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19617         *r = v;
19618         return NDR_ERR_SUCCESS;
19619 }
19620
19621 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19622 {
19623         ndr_print_uint32(ndr, name, r);
19624         ndr->depth++;
19625         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19626         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19627         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19628         ndr->depth--;
19629 }
19630
19631 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19632 {
19633         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19634         return NDR_ERR_SUCCESS;
19635 }
19636
19637 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19638 {
19639         uint32_t v;
19640         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19641         *r = v;
19642         return NDR_ERR_SUCCESS;
19643 }
19644
19645 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19646 {
19647         const char *val = NULL;
19648
19649         switch (r) {
19650                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19651                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19652         }
19653         ndr_print_enum(ndr, name, "ENUM", val, r);
19654 }
19655
19656 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19657 {
19658         if (ndr_flags & NDR_SCALARS) {
19659                 NDR_CHECK(ndr_push_align(ndr, 4));
19660                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19662                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19665                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19666                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19668                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19669                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19670                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19671                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19675                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19676         }
19677         if (ndr_flags & NDR_BUFFERS) {
19678         }
19679         return NDR_ERR_SUCCESS;
19680 }
19681
19682 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19683 {
19684         if (ndr_flags & NDR_SCALARS) {
19685                 NDR_CHECK(ndr_pull_align(ndr, 4));
19686                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19688                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19691                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19692                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19694                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19695                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19696                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19697                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19701                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19702         }
19703         if (ndr_flags & NDR_BUFFERS) {
19704         }
19705         return NDR_ERR_SUCCESS;
19706 }
19707
19708 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19709 {
19710         ndr_print_struct(ndr, name, "spoolss_PortData1");
19711         ndr->depth++;
19712         ndr_print_string(ndr, "portname", r->portname);
19713         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19714         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19715         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19716         ndr_print_uint32(ndr, "reserved", r->reserved);
19717         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19718         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19719         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19720         ndr_print_string(ndr, "queue", r->queue);
19721         ndr_print_string(ndr, "ip_address", r->ip_address);
19722         ndr_print_string(ndr, "hardware_address", r->hardware_address);
19723         ndr_print_string(ndr, "device_type", r->device_type);
19724         ndr_print_uint32(ndr, "port_number", r->port_number);
19725         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19726         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19727         ndr->depth--;
19728 }
19729
19730 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19731 {
19732         if (ndr_flags & NDR_SCALARS) {
19733                 NDR_CHECK(ndr_push_align(ndr, 4));
19734                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19736                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19739                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19740                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19742                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19743                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19748                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19749         }
19750         if (ndr_flags & NDR_BUFFERS) {
19751         }
19752         return NDR_ERR_SUCCESS;
19753 }
19754
19755 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19756 {
19757         if (ndr_flags & NDR_SCALARS) {
19758                 NDR_CHECK(ndr_pull_align(ndr, 4));
19759                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19761                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19764                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19765                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19767                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19768                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19773                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19774         }
19775         if (ndr_flags & NDR_BUFFERS) {
19776         }
19777         return NDR_ERR_SUCCESS;
19778 }
19779
19780 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19781 {
19782         ndr_print_struct(ndr, name, "spoolss_PortData2");
19783         ndr->depth++;
19784         ndr_print_string(ndr, "portname", r->portname);
19785         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19786         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19787         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19788         ndr_print_uint32(ndr, "reserved", r->reserved);
19789         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19790         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19791         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19792         ndr_print_string(ndr, "queue", r->queue);
19793         ndr_print_string(ndr, "device_type", r->device_type);
19794         ndr_print_uint32(ndr, "port_number", r->port_number);
19795         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19796         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19797         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19798         ndr->depth--;
19799 }
19800
19801 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19802 {
19803         if (ndr_flags & NDR_SCALARS) {
19804                 NDR_CHECK(ndr_push_align(ndr, 4));
19805                 {
19806                         uint32_t _flags_save_string = ndr->flags;
19807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19808                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19809                         ndr->flags = _flags_save_string;
19810                 }
19811                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19812         }
19813         if (ndr_flags & NDR_BUFFERS) {
19814         }
19815         return NDR_ERR_SUCCESS;
19816 }
19817
19818 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19819 {
19820         if (ndr_flags & NDR_SCALARS) {
19821                 NDR_CHECK(ndr_pull_align(ndr, 4));
19822                 {
19823                         uint32_t _flags_save_string = ndr->flags;
19824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19825                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19826                         ndr->flags = _flags_save_string;
19827                 }
19828                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19829         }
19830         if (ndr_flags & NDR_BUFFERS) {
19831         }
19832         return NDR_ERR_SUCCESS;
19833 }
19834
19835 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19836 {
19837         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19838         ndr->depth++;
19839         ndr_print_string(ndr, "dll_name", r->dll_name);
19840         ndr->depth--;
19841 }
19842
19843 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19844 {
19845         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19846         return NDR_ERR_SUCCESS;
19847 }
19848
19849 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19850 {
19851         uint32_t v;
19852         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19853         *r = v;
19854         return NDR_ERR_SUCCESS;
19855 }
19856
19857 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19858 {
19859         ndr_print_uint32(ndr, name, r);
19860         ndr->depth++;
19861         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
19862         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
19863         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
19864         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
19865         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
19866         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
19867         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
19868         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
19869         ndr->depth--;
19870 }
19871
19872 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
19873 {
19874         if (ndr_flags & NDR_SCALARS) {
19875                 NDR_CHECK(ndr_push_align(ndr, 8));
19876                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19877                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
19878                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
19879                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
19880                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
19881         }
19882         if (ndr_flags & NDR_BUFFERS) {
19883         }
19884         return NDR_ERR_SUCCESS;
19885 }
19886
19887 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
19888 {
19889         if (ndr_flags & NDR_SCALARS) {
19890                 NDR_CHECK(ndr_pull_align(ndr, 8));
19891                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19892                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
19893                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
19894                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
19895                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
19896         }
19897         if (ndr_flags & NDR_BUFFERS) {
19898         }
19899         return NDR_ERR_SUCCESS;
19900 }
19901
19902 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
19903 {
19904         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
19905         ndr->depth++;
19906         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
19907         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
19908         ndr_print_hyper(ndr, "driver_version", r->driver_version);
19909         ndr_print_string(ndr, "formname", r->formname);
19910         ndr->depth--;
19911 }
19912
19913 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
19914 {
19915         if (flags & NDR_IN) {
19916                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
19917                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19918                 if (r->in.server) {
19919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19920                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19922                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19923                 }
19924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19925                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19926                 if (r->in.buffer) {
19927                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19928                 }
19929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19930         }
19931         if (flags & NDR_OUT) {
19932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19933                 if (r->out.info) {
19934                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19935                 }
19936                 if (r->out.needed == NULL) {
19937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19938                 }
19939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19940                 if (r->out.count == NULL) {
19941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19942                 }
19943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19944                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19945         }
19946         return NDR_ERR_SUCCESS;
19947 }
19948
19949 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
19950 {
19951         uint32_t _ptr_server;
19952         uint32_t _ptr_buffer;
19953         uint32_t _ptr_info;
19954         TALLOC_CTX *_mem_save_server_0;
19955         TALLOC_CTX *_mem_save_buffer_0;
19956         TALLOC_CTX *_mem_save_info_0;
19957         TALLOC_CTX *_mem_save_needed_0;
19958         TALLOC_CTX *_mem_save_count_0;
19959         if (flags & NDR_IN) {
19960                 ZERO_STRUCT(r->out);
19961
19962                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
19963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19964                 if (_ptr_server) {
19965                         NDR_PULL_ALLOC(ndr, r->in.server);
19966                 } else {
19967                         r->in.server = NULL;
19968                 }
19969                 if (r->in.server) {
19970                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19971                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19972                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19973                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19974                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19975                                 return 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));
19976                         }
19977                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19978                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19979                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19980                 }
19981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19983                 if (_ptr_buffer) {
19984                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19985                 } else {
19986                         r->in.buffer = NULL;
19987                 }
19988                 if (r->in.buffer) {
19989                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19990                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19991                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19993                 }
19994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19995                 NDR_PULL_ALLOC(ndr, r->out.needed);
19996                 ZERO_STRUCTP(r->out.needed);
19997                 NDR_PULL_ALLOC(ndr, r->out.count);
19998                 ZERO_STRUCTP(r->out.count);
19999         }
20000         if (flags & NDR_OUT) {
20001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20002                 if (_ptr_info) {
20003                         NDR_PULL_ALLOC(ndr, r->out.info);
20004                 } else {
20005                         r->out.info = NULL;
20006                 }
20007                 if (r->out.info) {
20008                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20009                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20010                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20012                 }
20013                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20014                         NDR_PULL_ALLOC(ndr, r->out.needed);
20015                 }
20016                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20017                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20021                         NDR_PULL_ALLOC(ndr, r->out.count);
20022                 }
20023                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20027                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20028         }
20029         return NDR_ERR_SUCCESS;
20030 }
20031
20032 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20033 {
20034         uint32_t cntr_info_0;
20035         if (flags & NDR_IN) {
20036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20038         }
20039         if (flags & NDR_OUT) {
20040                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20041                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20042                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20043                 }
20044                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20045                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20046                 }
20047         }
20048         return NDR_ERR_SUCCESS;
20049 }
20050
20051 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20052 {
20053         uint32_t cntr_info_0;
20054         TALLOC_CTX *_mem_save_info_0;
20055         if (flags & NDR_IN) {
20056                 ZERO_STRUCT(r->out);
20057
20058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20060         }
20061         if (flags & NDR_OUT) {
20062                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20063                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20064                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20065                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20066                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20067                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20068                 }
20069                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20070                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20071                 }
20072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20073         }
20074         return NDR_ERR_SUCCESS;
20075 }
20076
20077 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20078 {
20079         uint32_t cntr_info_2;
20080         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20081         ndr->depth++;
20082         if (flags & NDR_SET_VALUES) {
20083                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20084         }
20085         if (flags & NDR_IN) {
20086                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20087                 ndr->depth++;
20088                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20089                 ndr_print_ptr(ndr, "server", r->in.server);
20090                 ndr->depth++;
20091                 if (r->in.server) {
20092                         ndr_print_string(ndr, "server", r->in.server);
20093                 }
20094                 ndr->depth--;
20095                 ndr_print_uint32(ndr, "level", r->in.level);
20096                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20097                 ndr->depth++;
20098                 if (r->in.buffer) {
20099                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20100                 }
20101                 ndr->depth--;
20102                 ndr_print_uint32(ndr, "offered", r->in.offered);
20103                 ndr->depth--;
20104         }
20105         if (flags & NDR_OUT) {
20106                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20107                 ndr->depth++;
20108                 ndr_print_ptr(ndr, "count", r->out.count);
20109                 ndr->depth++;
20110                 ndr_print_uint32(ndr, "count", *r->out.count);
20111                 ndr->depth--;
20112                 ndr_print_ptr(ndr, "info", r->out.info);
20113                 ndr->depth++;
20114                 ndr_print_ptr(ndr, "info", *r->out.info);
20115                 ndr->depth++;
20116                 if (*r->out.info) {
20117                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20118                         ndr->depth++;
20119                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20120                                 char *idx_2=NULL;
20121                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20122                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20123                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20124                                         free(idx_2);
20125                                 }
20126                         }
20127                         ndr->depth--;
20128                 }
20129                 ndr->depth--;
20130                 ndr->depth--;
20131                 ndr_print_ptr(ndr, "needed", r->out.needed);
20132                 ndr->depth++;
20133                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20134                 ndr->depth--;
20135                 ndr_print_WERROR(ndr, "result", r->out.result);
20136                 ndr->depth--;
20137         }
20138         ndr->depth--;
20139 }
20140
20141 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20142 {
20143         if (flags & NDR_IN) {
20144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20145                 if (r->in.printername) {
20146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20147                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20149                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20150                 }
20151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20152                 if (r->in.datatype) {
20153                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20154                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20156                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20157                 }
20158                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20159                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20160         }
20161         if (flags & NDR_OUT) {
20162                 if (r->out.handle == NULL) {
20163                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20164                 }
20165                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20166                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20167         }
20168         return NDR_ERR_SUCCESS;
20169 }
20170
20171 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20172 {
20173         uint32_t _ptr_printername;
20174         uint32_t _ptr_datatype;
20175         TALLOC_CTX *_mem_save_printername_0;
20176         TALLOC_CTX *_mem_save_datatype_0;
20177         TALLOC_CTX *_mem_save_handle_0;
20178         if (flags & NDR_IN) {
20179                 ZERO_STRUCT(r->out);
20180
20181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20182                 if (_ptr_printername) {
20183                         NDR_PULL_ALLOC(ndr, r->in.printername);
20184                 } else {
20185                         r->in.printername = NULL;
20186                 }
20187                 if (r->in.printername) {
20188                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20189                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20190                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20191                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20192                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20193                                 return 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));
20194                         }
20195                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20196                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20198                 }
20199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20200                 if (_ptr_datatype) {
20201                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20202                 } else {
20203                         r->in.datatype = NULL;
20204                 }
20205                 if (r->in.datatype) {
20206                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20207                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20210                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20211                                 return 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));
20212                         }
20213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20216                 }
20217                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20218                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20219                 NDR_PULL_ALLOC(ndr, r->out.handle);
20220                 ZERO_STRUCTP(r->out.handle);
20221         }
20222         if (flags & NDR_OUT) {
20223                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20224                         NDR_PULL_ALLOC(ndr, r->out.handle);
20225                 }
20226                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20227                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20228                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20229                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20230                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20231         }
20232         return NDR_ERR_SUCCESS;
20233 }
20234
20235 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20236 {
20237         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20238         ndr->depth++;
20239         if (flags & NDR_SET_VALUES) {
20240                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20241         }
20242         if (flags & NDR_IN) {
20243                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20244                 ndr->depth++;
20245                 ndr_print_ptr(ndr, "printername", r->in.printername);
20246                 ndr->depth++;
20247                 if (r->in.printername) {
20248                         ndr_print_string(ndr, "printername", r->in.printername);
20249                 }
20250                 ndr->depth--;
20251                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20252                 ndr->depth++;
20253                 if (r->in.datatype) {
20254                         ndr_print_string(ndr, "datatype", r->in.datatype);
20255                 }
20256                 ndr->depth--;
20257                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20258                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20259                 ndr->depth--;
20260         }
20261         if (flags & NDR_OUT) {
20262                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20263                 ndr->depth++;
20264                 ndr_print_ptr(ndr, "handle", r->out.handle);
20265                 ndr->depth++;
20266                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20267                 ndr->depth--;
20268                 ndr_print_WERROR(ndr, "result", r->out.result);
20269                 ndr->depth--;
20270         }
20271         ndr->depth--;
20272 }
20273
20274 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20275 {
20276         if (flags & NDR_IN) {
20277                 if (r->in.handle == NULL) {
20278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20279                 }
20280                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20283                 if (r->in.ctr) {
20284                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20285                 }
20286                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20287         }
20288         if (flags & NDR_OUT) {
20289                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20290         }
20291         return NDR_ERR_SUCCESS;
20292 }
20293
20294 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20295 {
20296         uint32_t _ptr_ctr;
20297         TALLOC_CTX *_mem_save_handle_0;
20298         TALLOC_CTX *_mem_save_ctr_0;
20299         if (flags & NDR_IN) {
20300                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20301                         NDR_PULL_ALLOC(ndr, r->in.handle);
20302                 }
20303                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20304                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20305                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20306                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20309                 if (_ptr_ctr) {
20310                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20311                 } else {
20312                         r->in.ctr = NULL;
20313                 }
20314                 if (r->in.ctr) {
20315                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20316                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20317                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20319                 }
20320                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20321         }
20322         if (flags & NDR_OUT) {
20323                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20324         }
20325         return NDR_ERR_SUCCESS;
20326 }
20327
20328 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20329 {
20330         ndr_print_struct(ndr, name, "spoolss_SetJob");
20331         ndr->depth++;
20332         if (flags & NDR_SET_VALUES) {
20333                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20334         }
20335         if (flags & NDR_IN) {
20336                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20337                 ndr->depth++;
20338                 ndr_print_ptr(ndr, "handle", r->in.handle);
20339                 ndr->depth++;
20340                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20341                 ndr->depth--;
20342                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20343                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20344                 ndr->depth++;
20345                 if (r->in.ctr) {
20346                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20347                 }
20348                 ndr->depth--;
20349                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20350                 ndr->depth--;
20351         }
20352         if (flags & NDR_OUT) {
20353                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20354                 ndr->depth++;
20355                 ndr_print_WERROR(ndr, "result", r->out.result);
20356                 ndr->depth--;
20357         }
20358         ndr->depth--;
20359 }
20360
20361 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20362 {
20363         if (flags & NDR_IN) {
20364                 if (r->in.handle == NULL) {
20365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20366                 }
20367                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20371                 if (r->in.buffer) {
20372                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20373                 }
20374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20375         }
20376         if (flags & NDR_OUT) {
20377                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20378                 if (r->out.info) {
20379                         {
20380                                 struct ndr_push *_ndr_info;
20381                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20382                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20383                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20384                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20385                         }
20386                 }
20387                 if (r->out.needed == NULL) {
20388                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20389                 }
20390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20392         }
20393         return NDR_ERR_SUCCESS;
20394 }
20395
20396 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20397 {
20398         uint32_t _ptr_buffer;
20399         uint32_t _ptr_info;
20400         TALLOC_CTX *_mem_save_handle_0;
20401         TALLOC_CTX *_mem_save_buffer_0;
20402         TALLOC_CTX *_mem_save_info_0;
20403         TALLOC_CTX *_mem_save_needed_0;
20404         if (flags & NDR_IN) {
20405                 ZERO_STRUCT(r->out);
20406
20407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20408                         NDR_PULL_ALLOC(ndr, r->in.handle);
20409                 }
20410                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20411                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20412                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20417                 if (_ptr_buffer) {
20418                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20419                 } else {
20420                         r->in.buffer = NULL;
20421                 }
20422                 if (r->in.buffer) {
20423                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20424                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20425                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20427                 }
20428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20429                 NDR_PULL_ALLOC(ndr, r->out.needed);
20430                 ZERO_STRUCTP(r->out.needed);
20431         }
20432         if (flags & NDR_OUT) {
20433                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20434                 if (_ptr_info) {
20435                         NDR_PULL_ALLOC(ndr, r->out.info);
20436                 } else {
20437                         r->out.info = NULL;
20438                 }
20439                 if (r->out.info) {
20440                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20441                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20442                         {
20443                                 struct ndr_pull *_ndr_info;
20444                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20445                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20446                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20447                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20448                         }
20449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20450                 }
20451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20452                         NDR_PULL_ALLOC(ndr, r->out.needed);
20453                 }
20454                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20455                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20458                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20459         }
20460         return NDR_ERR_SUCCESS;
20461 }
20462
20463 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20464 {
20465         ndr_print_struct(ndr, name, "spoolss_GetJob");
20466         ndr->depth++;
20467         if (flags & NDR_SET_VALUES) {
20468                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20469         }
20470         if (flags & NDR_IN) {
20471                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
20472                 ndr->depth++;
20473                 ndr_print_ptr(ndr, "handle", r->in.handle);
20474                 ndr->depth++;
20475                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20476                 ndr->depth--;
20477                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20478                 ndr_print_uint32(ndr, "level", r->in.level);
20479                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20480                 ndr->depth++;
20481                 if (r->in.buffer) {
20482                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20483                 }
20484                 ndr->depth--;
20485                 ndr_print_uint32(ndr, "offered", r->in.offered);
20486                 ndr->depth--;
20487         }
20488         if (flags & NDR_OUT) {
20489                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
20490                 ndr->depth++;
20491                 ndr_print_ptr(ndr, "info", r->out.info);
20492                 ndr->depth++;
20493                 if (r->out.info) {
20494                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20495                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20496                 }
20497                 ndr->depth--;
20498                 ndr_print_ptr(ndr, "needed", r->out.needed);
20499                 ndr->depth++;
20500                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20501                 ndr->depth--;
20502                 ndr_print_WERROR(ndr, "result", r->out.result);
20503                 ndr->depth--;
20504         }
20505         ndr->depth--;
20506 }
20507
20508 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20509 {
20510         if (flags & NDR_IN) {
20511                 if (r->in.handle == NULL) {
20512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20513                 }
20514                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20519                 if (r->in.buffer) {
20520                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20521                 }
20522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20523         }
20524         if (flags & NDR_OUT) {
20525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20526                 if (r->out.info) {
20527                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20528                 }
20529                 if (r->out.needed == NULL) {
20530                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20531                 }
20532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20533                 if (r->out.count == NULL) {
20534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20535                 }
20536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20537                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20538         }
20539         return NDR_ERR_SUCCESS;
20540 }
20541
20542 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20543 {
20544         uint32_t _ptr_buffer;
20545         uint32_t _ptr_info;
20546         TALLOC_CTX *_mem_save_handle_0;
20547         TALLOC_CTX *_mem_save_buffer_0;
20548         TALLOC_CTX *_mem_save_info_0;
20549         TALLOC_CTX *_mem_save_needed_0;
20550         TALLOC_CTX *_mem_save_count_0;
20551         if (flags & NDR_IN) {
20552                 ZERO_STRUCT(r->out);
20553
20554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20555                         NDR_PULL_ALLOC(ndr, r->in.handle);
20556                 }
20557                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20558                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20559                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20565                 if (_ptr_buffer) {
20566                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20567                 } else {
20568                         r->in.buffer = NULL;
20569                 }
20570                 if (r->in.buffer) {
20571                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20572                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20573                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20575                 }
20576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20577                 NDR_PULL_ALLOC(ndr, r->out.needed);
20578                 ZERO_STRUCTP(r->out.needed);
20579                 NDR_PULL_ALLOC(ndr, r->out.count);
20580                 ZERO_STRUCTP(r->out.count);
20581         }
20582         if (flags & NDR_OUT) {
20583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20584                 if (_ptr_info) {
20585                         NDR_PULL_ALLOC(ndr, r->out.info);
20586                 } else {
20587                         r->out.info = NULL;
20588                 }
20589                 if (r->out.info) {
20590                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20591                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20592                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20594                 }
20595                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20596                         NDR_PULL_ALLOC(ndr, r->out.needed);
20597                 }
20598                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20599                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20602                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20603                         NDR_PULL_ALLOC(ndr, r->out.count);
20604                 }
20605                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20606                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20608                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20609                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20610         }
20611         return NDR_ERR_SUCCESS;
20612 }
20613
20614 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20615 {
20616         uint32_t cntr_info_0;
20617         if (flags & NDR_IN) {
20618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20620         }
20621         if (flags & NDR_OUT) {
20622                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20623                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20624                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20625                 }
20626                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20627                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20628                 }
20629         }
20630         return NDR_ERR_SUCCESS;
20631 }
20632
20633 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20634 {
20635         uint32_t cntr_info_0;
20636         TALLOC_CTX *_mem_save_info_0;
20637         if (flags & NDR_IN) {
20638                 ZERO_STRUCT(r->out);
20639
20640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20642         }
20643         if (flags & NDR_OUT) {
20644                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20645                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20646                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20647                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20648                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20649                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20650                 }
20651                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20652                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20653                 }
20654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20655         }
20656         return NDR_ERR_SUCCESS;
20657 }
20658
20659 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20660 {
20661         uint32_t cntr_info_2;
20662         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20663         ndr->depth++;
20664         if (flags & NDR_SET_VALUES) {
20665                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20666         }
20667         if (flags & NDR_IN) {
20668                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20669                 ndr->depth++;
20670                 ndr_print_ptr(ndr, "handle", r->in.handle);
20671                 ndr->depth++;
20672                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20673                 ndr->depth--;
20674                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20675                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20676                 ndr_print_uint32(ndr, "level", r->in.level);
20677                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20678                 ndr->depth++;
20679                 if (r->in.buffer) {
20680                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20681                 }
20682                 ndr->depth--;
20683                 ndr_print_uint32(ndr, "offered", r->in.offered);
20684                 ndr->depth--;
20685         }
20686         if (flags & NDR_OUT) {
20687                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20688                 ndr->depth++;
20689                 ndr_print_ptr(ndr, "count", r->out.count);
20690                 ndr->depth++;
20691                 ndr_print_uint32(ndr, "count", *r->out.count);
20692                 ndr->depth--;
20693                 ndr_print_ptr(ndr, "info", r->out.info);
20694                 ndr->depth++;
20695                 ndr_print_ptr(ndr, "info", *r->out.info);
20696                 ndr->depth++;
20697                 if (*r->out.info) {
20698                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20699                         ndr->depth++;
20700                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20701                                 char *idx_2=NULL;
20702                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20703                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20704                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20705                                         free(idx_2);
20706                                 }
20707                         }
20708                         ndr->depth--;
20709                 }
20710                 ndr->depth--;
20711                 ndr->depth--;
20712                 ndr_print_ptr(ndr, "needed", r->out.needed);
20713                 ndr->depth++;
20714                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20715                 ndr->depth--;
20716                 ndr_print_WERROR(ndr, "result", r->out.result);
20717                 ndr->depth--;
20718         }
20719         ndr->depth--;
20720 }
20721
20722 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20723 {
20724         if (flags & NDR_IN) {
20725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20726                 if (r->in.server) {
20727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20731                 }
20732                 if (r->in.info_ctr == NULL) {
20733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20734                 }
20735                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20736                 if (r->in.devmode_ctr == NULL) {
20737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20738                 }
20739                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20740                 if (r->in.secdesc_ctr == NULL) {
20741                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20742                 }
20743                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20744         }
20745         if (flags & NDR_OUT) {
20746                 if (r->out.handle == NULL) {
20747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20748                 }
20749                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20750                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20751         }
20752         return NDR_ERR_SUCCESS;
20753 }
20754
20755 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20756 {
20757         uint32_t _ptr_server;
20758         TALLOC_CTX *_mem_save_server_0;
20759         TALLOC_CTX *_mem_save_info_ctr_0;
20760         TALLOC_CTX *_mem_save_devmode_ctr_0;
20761         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20762         TALLOC_CTX *_mem_save_handle_0;
20763         if (flags & NDR_IN) {
20764                 ZERO_STRUCT(r->out);
20765
20766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20767                 if (_ptr_server) {
20768                         NDR_PULL_ALLOC(ndr, r->in.server);
20769                 } else {
20770                         r->in.server = NULL;
20771                 }
20772                 if (r->in.server) {
20773                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20774                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20776                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20777                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20778                                 return 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));
20779                         }
20780                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20781                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20783                 }
20784                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20785                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20786                 }
20787                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20788                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20789                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20790                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20791                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20792                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20793                 }
20794                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20795                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20796                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20799                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20800                 }
20801                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20802                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20803                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20805                 NDR_PULL_ALLOC(ndr, r->out.handle);
20806                 ZERO_STRUCTP(r->out.handle);
20807         }
20808         if (flags & NDR_OUT) {
20809                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20810                         NDR_PULL_ALLOC(ndr, r->out.handle);
20811                 }
20812                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20813                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20814                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20816                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20817         }
20818         return NDR_ERR_SUCCESS;
20819 }
20820
20821 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20822 {
20823         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20824         ndr->depth++;
20825         if (flags & NDR_SET_VALUES) {
20826                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20827         }
20828         if (flags & NDR_IN) {
20829                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20830                 ndr->depth++;
20831                 ndr_print_ptr(ndr, "server", r->in.server);
20832                 ndr->depth++;
20833                 if (r->in.server) {
20834                         ndr_print_string(ndr, "server", r->in.server);
20835                 }
20836                 ndr->depth--;
20837                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20838                 ndr->depth++;
20839                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20840                 ndr->depth--;
20841                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20842                 ndr->depth++;
20843                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20844                 ndr->depth--;
20845                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20846                 ndr->depth++;
20847                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20848                 ndr->depth--;
20849                 ndr->depth--;
20850         }
20851         if (flags & NDR_OUT) {
20852                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
20853                 ndr->depth++;
20854                 ndr_print_ptr(ndr, "handle", r->out.handle);
20855                 ndr->depth++;
20856                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20857                 ndr->depth--;
20858                 ndr_print_WERROR(ndr, "result", r->out.result);
20859                 ndr->depth--;
20860         }
20861         ndr->depth--;
20862 }
20863
20864 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
20865 {
20866         if (flags & NDR_IN) {
20867                 if (r->in.handle == NULL) {
20868                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20869                 }
20870                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20871         }
20872         if (flags & NDR_OUT) {
20873                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20874         }
20875         return NDR_ERR_SUCCESS;
20876 }
20877
20878 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
20879 {
20880         TALLOC_CTX *_mem_save_handle_0;
20881         if (flags & NDR_IN) {
20882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20883                         NDR_PULL_ALLOC(ndr, r->in.handle);
20884                 }
20885                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20886                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20887                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20889         }
20890         if (flags & NDR_OUT) {
20891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20892         }
20893         return NDR_ERR_SUCCESS;
20894 }
20895
20896 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
20897 {
20898         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
20899         ndr->depth++;
20900         if (flags & NDR_SET_VALUES) {
20901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20902         }
20903         if (flags & NDR_IN) {
20904                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
20905                 ndr->depth++;
20906                 ndr_print_ptr(ndr, "handle", r->in.handle);
20907                 ndr->depth++;
20908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20909                 ndr->depth--;
20910                 ndr->depth--;
20911         }
20912         if (flags & NDR_OUT) {
20913                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
20914                 ndr->depth++;
20915                 ndr_print_WERROR(ndr, "result", r->out.result);
20916                 ndr->depth--;
20917         }
20918         ndr->depth--;
20919 }
20920
20921 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
20922 {
20923         if (flags & NDR_IN) {
20924                 if (r->in.handle == NULL) {
20925                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20926                 }
20927                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20928                 if (r->in.info_ctr == NULL) {
20929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20930                 }
20931                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20932                 if (r->in.devmode_ctr == NULL) {
20933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20934                 }
20935                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20936                 if (r->in.secdesc_ctr == NULL) {
20937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20938                 }
20939                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20940                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
20941         }
20942         if (flags & NDR_OUT) {
20943                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20944         }
20945         return NDR_ERR_SUCCESS;
20946 }
20947
20948 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
20949 {
20950         TALLOC_CTX *_mem_save_handle_0;
20951         TALLOC_CTX *_mem_save_info_ctr_0;
20952         TALLOC_CTX *_mem_save_devmode_ctr_0;
20953         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20954         if (flags & NDR_IN) {
20955                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20956                         NDR_PULL_ALLOC(ndr, r->in.handle);
20957                 }
20958                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20959                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20960                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20962                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20963                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20964                 }
20965                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20966                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20967                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20968                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20969                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20970                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20971                 }
20972                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20973                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20974                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20975                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20976                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20977                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20978                 }
20979                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20980                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20981                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20982                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20983                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
20984         }
20985         if (flags & NDR_OUT) {
20986                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20987         }
20988         return NDR_ERR_SUCCESS;
20989 }
20990
20991 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
20992 {
20993         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
20994         ndr->depth++;
20995         if (flags & NDR_SET_VALUES) {
20996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20997         }
20998         if (flags & NDR_IN) {
20999                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21000                 ndr->depth++;
21001                 ndr_print_ptr(ndr, "handle", r->in.handle);
21002                 ndr->depth++;
21003                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21004                 ndr->depth--;
21005                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21006                 ndr->depth++;
21007                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21008                 ndr->depth--;
21009                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21010                 ndr->depth++;
21011                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21012                 ndr->depth--;
21013                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21014                 ndr->depth++;
21015                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21016                 ndr->depth--;
21017                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21018                 ndr->depth--;
21019         }
21020         if (flags & NDR_OUT) {
21021                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21022                 ndr->depth++;
21023                 ndr_print_WERROR(ndr, "result", r->out.result);
21024                 ndr->depth--;
21025         }
21026         ndr->depth--;
21027 }
21028
21029 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21030 {
21031         if (flags & NDR_IN) {
21032                 if (r->in.handle == NULL) {
21033                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21034                 }
21035                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21038                 if (r->in.buffer) {
21039                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21040                 }
21041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21042         }
21043         if (flags & NDR_OUT) {
21044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21045                 if (r->out.info) {
21046                         {
21047                                 struct ndr_push *_ndr_info;
21048                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21049                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21050                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21051                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21052                         }
21053                 }
21054                 if (r->out.needed == NULL) {
21055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21056                 }
21057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21058                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21059         }
21060         return NDR_ERR_SUCCESS;
21061 }
21062
21063 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21064 {
21065         uint32_t _ptr_buffer;
21066         uint32_t _ptr_info;
21067         TALLOC_CTX *_mem_save_handle_0;
21068         TALLOC_CTX *_mem_save_buffer_0;
21069         TALLOC_CTX *_mem_save_info_0;
21070         TALLOC_CTX *_mem_save_needed_0;
21071         if (flags & NDR_IN) {
21072                 ZERO_STRUCT(r->out);
21073
21074                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21075                         NDR_PULL_ALLOC(ndr, r->in.handle);
21076                 }
21077                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21078                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21079                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21080                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21083                 if (_ptr_buffer) {
21084                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21085                 } else {
21086                         r->in.buffer = NULL;
21087                 }
21088                 if (r->in.buffer) {
21089                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21090                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21091                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21093                 }
21094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21095                 NDR_PULL_ALLOC(ndr, r->out.needed);
21096                 ZERO_STRUCTP(r->out.needed);
21097         }
21098         if (flags & NDR_OUT) {
21099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21100                 if (_ptr_info) {
21101                         NDR_PULL_ALLOC(ndr, r->out.info);
21102                 } else {
21103                         r->out.info = NULL;
21104                 }
21105                 if (r->out.info) {
21106                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21107                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21108                         {
21109                                 struct ndr_pull *_ndr_info;
21110                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21111                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21112                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21113                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21114                         }
21115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21116                 }
21117                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21118                         NDR_PULL_ALLOC(ndr, r->out.needed);
21119                 }
21120                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21121                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21124                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21125         }
21126         return NDR_ERR_SUCCESS;
21127 }
21128
21129 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21130 {
21131         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21132         ndr->depth++;
21133         if (flags & NDR_SET_VALUES) {
21134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21135         }
21136         if (flags & NDR_IN) {
21137                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21138                 ndr->depth++;
21139                 ndr_print_ptr(ndr, "handle", r->in.handle);
21140                 ndr->depth++;
21141                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21142                 ndr->depth--;
21143                 ndr_print_uint32(ndr, "level", r->in.level);
21144                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21145                 ndr->depth++;
21146                 if (r->in.buffer) {
21147                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21148                 }
21149                 ndr->depth--;
21150                 ndr_print_uint32(ndr, "offered", r->in.offered);
21151                 ndr->depth--;
21152         }
21153         if (flags & NDR_OUT) {
21154                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21155                 ndr->depth++;
21156                 ndr_print_ptr(ndr, "info", r->out.info);
21157                 ndr->depth++;
21158                 if (r->out.info) {
21159                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21160                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21161                 }
21162                 ndr->depth--;
21163                 ndr_print_ptr(ndr, "needed", r->out.needed);
21164                 ndr->depth++;
21165                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21166                 ndr->depth--;
21167                 ndr_print_WERROR(ndr, "result", r->out.result);
21168                 ndr->depth--;
21169         }
21170         ndr->depth--;
21171 }
21172
21173 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21174 {
21175         if (flags & NDR_IN) {
21176                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21177                 if (r->in.servername) {
21178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21179                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21181                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21182                 }
21183                 if (r->in.info_ctr == NULL) {
21184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21185                 }
21186                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21187         }
21188         if (flags & NDR_OUT) {
21189                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21190         }
21191         return NDR_ERR_SUCCESS;
21192 }
21193
21194 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21195 {
21196         uint32_t _ptr_servername;
21197         TALLOC_CTX *_mem_save_servername_0;
21198         TALLOC_CTX *_mem_save_info_ctr_0;
21199         if (flags & NDR_IN) {
21200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21201                 if (_ptr_servername) {
21202                         NDR_PULL_ALLOC(ndr, r->in.servername);
21203                 } else {
21204                         r->in.servername = NULL;
21205                 }
21206                 if (r->in.servername) {
21207                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21208                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21211                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21212                                 return 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));
21213                         }
21214                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21215                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21217                 }
21218                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21219                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21220                 }
21221                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21222                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21223                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21224                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21225         }
21226         if (flags & NDR_OUT) {
21227                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21228         }
21229         return NDR_ERR_SUCCESS;
21230 }
21231
21232 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21233 {
21234         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21235         ndr->depth++;
21236         if (flags & NDR_SET_VALUES) {
21237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21238         }
21239         if (flags & NDR_IN) {
21240                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21241                 ndr->depth++;
21242                 ndr_print_ptr(ndr, "servername", r->in.servername);
21243                 ndr->depth++;
21244                 if (r->in.servername) {
21245                         ndr_print_string(ndr, "servername", r->in.servername);
21246                 }
21247                 ndr->depth--;
21248                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21249                 ndr->depth++;
21250                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21251                 ndr->depth--;
21252                 ndr->depth--;
21253         }
21254         if (flags & NDR_OUT) {
21255                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21256                 ndr->depth++;
21257                 ndr_print_WERROR(ndr, "result", r->out.result);
21258                 ndr->depth--;
21259         }
21260         ndr->depth--;
21261 }
21262
21263 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21264 {
21265         if (flags & NDR_IN) {
21266                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21267                 if (r->in.server) {
21268                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21270                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21271                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21272                 }
21273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21274                 if (r->in.environment) {
21275                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21276                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21278                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21279                 }
21280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21281                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21282                 if (r->in.buffer) {
21283                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21284                 }
21285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21286         }
21287         if (flags & NDR_OUT) {
21288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21289                 if (r->out.info) {
21290                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21291                 }
21292                 if (r->out.needed == NULL) {
21293                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21294                 }
21295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21296                 if (r->out.count == NULL) {
21297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21298                 }
21299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21300                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21301         }
21302         return NDR_ERR_SUCCESS;
21303 }
21304
21305 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21306 {
21307         uint32_t _ptr_server;
21308         uint32_t _ptr_environment;
21309         uint32_t _ptr_buffer;
21310         uint32_t _ptr_info;
21311         TALLOC_CTX *_mem_save_server_0;
21312         TALLOC_CTX *_mem_save_environment_0;
21313         TALLOC_CTX *_mem_save_buffer_0;
21314         TALLOC_CTX *_mem_save_info_0;
21315         TALLOC_CTX *_mem_save_needed_0;
21316         TALLOC_CTX *_mem_save_count_0;
21317         if (flags & NDR_IN) {
21318                 ZERO_STRUCT(r->out);
21319
21320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21321                 if (_ptr_server) {
21322                         NDR_PULL_ALLOC(ndr, r->in.server);
21323                 } else {
21324                         r->in.server = NULL;
21325                 }
21326                 if (r->in.server) {
21327                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21328                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21331                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21332                                 return 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));
21333                         }
21334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21337                 }
21338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21339                 if (_ptr_environment) {
21340                         NDR_PULL_ALLOC(ndr, r->in.environment);
21341                 } else {
21342                         r->in.environment = NULL;
21343                 }
21344                 if (r->in.environment) {
21345                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21346                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21347                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21348                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21349                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21350                                 return 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));
21351                         }
21352                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21353                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21355                 }
21356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21358                 if (_ptr_buffer) {
21359                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21360                 } else {
21361                         r->in.buffer = NULL;
21362                 }
21363                 if (r->in.buffer) {
21364                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21365                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21366                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21368                 }
21369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21370                 NDR_PULL_ALLOC(ndr, r->out.needed);
21371                 ZERO_STRUCTP(r->out.needed);
21372                 NDR_PULL_ALLOC(ndr, r->out.count);
21373                 ZERO_STRUCTP(r->out.count);
21374         }
21375         if (flags & NDR_OUT) {
21376                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21377                 if (_ptr_info) {
21378                         NDR_PULL_ALLOC(ndr, r->out.info);
21379                 } else {
21380                         r->out.info = NULL;
21381                 }
21382                 if (r->out.info) {
21383                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21384                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21385                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21387                 }
21388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21389                         NDR_PULL_ALLOC(ndr, r->out.needed);
21390                 }
21391                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21392                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21395                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21396                         NDR_PULL_ALLOC(ndr, r->out.count);
21397                 }
21398                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21399                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21402                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21403         }
21404         return NDR_ERR_SUCCESS;
21405 }
21406
21407 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21408 {
21409         uint32_t cntr_info_0;
21410         if (flags & NDR_IN) {
21411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21413         }
21414         if (flags & NDR_OUT) {
21415                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21416                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21417                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21418                 }
21419                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21420                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21421                 }
21422         }
21423         return NDR_ERR_SUCCESS;
21424 }
21425
21426 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21427 {
21428         uint32_t cntr_info_0;
21429         TALLOC_CTX *_mem_save_info_0;
21430         if (flags & NDR_IN) {
21431                 ZERO_STRUCT(r->out);
21432
21433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21435         }
21436         if (flags & NDR_OUT) {
21437                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21438                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21439                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21440                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21441                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21442                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21443                 }
21444                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21445                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21446                 }
21447                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21448         }
21449         return NDR_ERR_SUCCESS;
21450 }
21451
21452 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21453 {
21454         uint32_t cntr_info_2;
21455         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21456         ndr->depth++;
21457         if (flags & NDR_SET_VALUES) {
21458                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21459         }
21460         if (flags & NDR_IN) {
21461                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21462                 ndr->depth++;
21463                 ndr_print_ptr(ndr, "server", r->in.server);
21464                 ndr->depth++;
21465                 if (r->in.server) {
21466                         ndr_print_string(ndr, "server", r->in.server);
21467                 }
21468                 ndr->depth--;
21469                 ndr_print_ptr(ndr, "environment", r->in.environment);
21470                 ndr->depth++;
21471                 if (r->in.environment) {
21472                         ndr_print_string(ndr, "environment", r->in.environment);
21473                 }
21474                 ndr->depth--;
21475                 ndr_print_uint32(ndr, "level", r->in.level);
21476                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21477                 ndr->depth++;
21478                 if (r->in.buffer) {
21479                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21480                 }
21481                 ndr->depth--;
21482                 ndr_print_uint32(ndr, "offered", r->in.offered);
21483                 ndr->depth--;
21484         }
21485         if (flags & NDR_OUT) {
21486                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21487                 ndr->depth++;
21488                 ndr_print_ptr(ndr, "count", r->out.count);
21489                 ndr->depth++;
21490                 ndr_print_uint32(ndr, "count", *r->out.count);
21491                 ndr->depth--;
21492                 ndr_print_ptr(ndr, "info", r->out.info);
21493                 ndr->depth++;
21494                 ndr_print_ptr(ndr, "info", *r->out.info);
21495                 ndr->depth++;
21496                 if (*r->out.info) {
21497                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21498                         ndr->depth++;
21499                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21500                                 char *idx_2=NULL;
21501                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21502                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21503                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21504                                         free(idx_2);
21505                                 }
21506                         }
21507                         ndr->depth--;
21508                 }
21509                 ndr->depth--;
21510                 ndr->depth--;
21511                 ndr_print_ptr(ndr, "needed", r->out.needed);
21512                 ndr->depth++;
21513                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21514                 ndr->depth--;
21515                 ndr_print_WERROR(ndr, "result", r->out.result);
21516                 ndr->depth--;
21517         }
21518         ndr->depth--;
21519 }
21520
21521 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21522 {
21523         if (flags & NDR_IN) {
21524                 if (r->in.handle == NULL) {
21525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21526                 }
21527                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21528                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21529                 if (r->in.architecture) {
21530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21531                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21532                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21533                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21534                 }
21535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21536                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21537                 if (r->in.buffer) {
21538                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21539                 }
21540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21541         }
21542         if (flags & NDR_OUT) {
21543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21544                 if (r->out.info) {
21545                         {
21546                                 struct ndr_push *_ndr_info;
21547                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21548                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21549                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21550                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21551                         }
21552                 }
21553                 if (r->out.needed == NULL) {
21554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21555                 }
21556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21557                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21558         }
21559         return NDR_ERR_SUCCESS;
21560 }
21561
21562 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
21563 {
21564         uint32_t _ptr_architecture;
21565         uint32_t _ptr_buffer;
21566         uint32_t _ptr_info;
21567         TALLOC_CTX *_mem_save_handle_0;
21568         TALLOC_CTX *_mem_save_architecture_0;
21569         TALLOC_CTX *_mem_save_buffer_0;
21570         TALLOC_CTX *_mem_save_info_0;
21571         TALLOC_CTX *_mem_save_needed_0;
21572         if (flags & NDR_IN) {
21573                 ZERO_STRUCT(r->out);
21574
21575                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21576                         NDR_PULL_ALLOC(ndr, r->in.handle);
21577                 }
21578                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21579                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21580                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21581                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21583                 if (_ptr_architecture) {
21584                         NDR_PULL_ALLOC(ndr, r->in.architecture);
21585                 } else {
21586                         r->in.architecture = NULL;
21587                 }
21588                 if (r->in.architecture) {
21589                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21590                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21593                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21594                                 return 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));
21595                         }
21596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21599                 }
21600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21602                 if (_ptr_buffer) {
21603                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21604                 } else {
21605                         r->in.buffer = NULL;
21606                 }
21607                 if (r->in.buffer) {
21608                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21609                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21610                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21612                 }
21613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21614                 NDR_PULL_ALLOC(ndr, r->out.needed);
21615                 ZERO_STRUCTP(r->out.needed);
21616         }
21617         if (flags & NDR_OUT) {
21618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21619                 if (_ptr_info) {
21620                         NDR_PULL_ALLOC(ndr, r->out.info);
21621                 } else {
21622                         r->out.info = NULL;
21623                 }
21624                 if (r->out.info) {
21625                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21626                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21627                         {
21628                                 struct ndr_pull *_ndr_info;
21629                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21630                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21631                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21632                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21633                         }
21634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21635                 }
21636                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21637                         NDR_PULL_ALLOC(ndr, r->out.needed);
21638                 }
21639                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21640                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21643                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21644         }
21645         return NDR_ERR_SUCCESS;
21646 }
21647
21648 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21649 {
21650         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21651         ndr->depth++;
21652         if (flags & NDR_SET_VALUES) {
21653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21654         }
21655         if (flags & NDR_IN) {
21656                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21657                 ndr->depth++;
21658                 ndr_print_ptr(ndr, "handle", r->in.handle);
21659                 ndr->depth++;
21660                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21661                 ndr->depth--;
21662                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21663                 ndr->depth++;
21664                 if (r->in.architecture) {
21665                         ndr_print_string(ndr, "architecture", r->in.architecture);
21666                 }
21667                 ndr->depth--;
21668                 ndr_print_uint32(ndr, "level", r->in.level);
21669                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21670                 ndr->depth++;
21671                 if (r->in.buffer) {
21672                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21673                 }
21674                 ndr->depth--;
21675                 ndr_print_uint32(ndr, "offered", r->in.offered);
21676                 ndr->depth--;
21677         }
21678         if (flags & NDR_OUT) {
21679                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
21680                 ndr->depth++;
21681                 ndr_print_ptr(ndr, "info", r->out.info);
21682                 ndr->depth++;
21683                 if (r->out.info) {
21684                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21685                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
21686                 }
21687                 ndr->depth--;
21688                 ndr_print_ptr(ndr, "needed", r->out.needed);
21689                 ndr->depth++;
21690                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21691                 ndr->depth--;
21692                 ndr_print_WERROR(ndr, "result", r->out.result);
21693                 ndr->depth--;
21694         }
21695         ndr->depth--;
21696 }
21697
21698 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21699 {
21700         if (flags & NDR_IN) {
21701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21702                 if (r->in.server) {
21703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21706                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21707                 }
21708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21709                 if (r->in.environment) {
21710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21712                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21714                 }
21715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21717                 if (r->in.buffer) {
21718                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21719                 }
21720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21721         }
21722         if (flags & NDR_OUT) {
21723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21724                 if (r->out.info) {
21725                         {
21726                                 struct ndr_push *_ndr_info;
21727                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21728                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21729                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21730                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21731                         }
21732                 }
21733                 if (r->out.needed == NULL) {
21734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21735                 }
21736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21737                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21738         }
21739         return NDR_ERR_SUCCESS;
21740 }
21741
21742 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
21743 {
21744         uint32_t _ptr_server;
21745         uint32_t _ptr_environment;
21746         uint32_t _ptr_buffer;
21747         uint32_t _ptr_info;
21748         TALLOC_CTX *_mem_save_server_0;
21749         TALLOC_CTX *_mem_save_environment_0;
21750         TALLOC_CTX *_mem_save_buffer_0;
21751         TALLOC_CTX *_mem_save_info_0;
21752         TALLOC_CTX *_mem_save_needed_0;
21753         if (flags & NDR_IN) {
21754                 ZERO_STRUCT(r->out);
21755
21756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21757                 if (_ptr_server) {
21758                         NDR_PULL_ALLOC(ndr, r->in.server);
21759                 } else {
21760                         r->in.server = NULL;
21761                 }
21762                 if (r->in.server) {
21763                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21764                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21767                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21768                                 return 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));
21769                         }
21770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21773                 }
21774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21775                 if (_ptr_environment) {
21776                         NDR_PULL_ALLOC(ndr, r->in.environment);
21777                 } else {
21778                         r->in.environment = NULL;
21779                 }
21780                 if (r->in.environment) {
21781                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21782                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21783                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21784                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21785                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21786                                 return 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));
21787                         }
21788                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21789                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21791                 }
21792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21794                 if (_ptr_buffer) {
21795                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21796                 } else {
21797                         r->in.buffer = NULL;
21798                 }
21799                 if (r->in.buffer) {
21800                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21801                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21802                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21804                 }
21805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21806                 NDR_PULL_ALLOC(ndr, r->out.needed);
21807                 ZERO_STRUCTP(r->out.needed);
21808         }
21809         if (flags & NDR_OUT) {
21810                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21811                 if (_ptr_info) {
21812                         NDR_PULL_ALLOC(ndr, r->out.info);
21813                 } else {
21814                         r->out.info = NULL;
21815                 }
21816                 if (r->out.info) {
21817                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21818                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21819                         {
21820                                 struct ndr_pull *_ndr_info;
21821                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21822                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21823                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21824                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21825                         }
21826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21827                 }
21828                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21829                         NDR_PULL_ALLOC(ndr, r->out.needed);
21830                 }
21831                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21832                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21835                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21836         }
21837         return NDR_ERR_SUCCESS;
21838 }
21839
21840 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21841 {
21842         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
21843         ndr->depth++;
21844         if (flags & NDR_SET_VALUES) {
21845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21846         }
21847         if (flags & NDR_IN) {
21848                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
21849                 ndr->depth++;
21850                 ndr_print_ptr(ndr, "server", r->in.server);
21851                 ndr->depth++;
21852                 if (r->in.server) {
21853                         ndr_print_string(ndr, "server", r->in.server);
21854                 }
21855                 ndr->depth--;
21856                 ndr_print_ptr(ndr, "environment", r->in.environment);
21857                 ndr->depth++;
21858                 if (r->in.environment) {
21859                         ndr_print_string(ndr, "environment", r->in.environment);
21860                 }
21861                 ndr->depth--;
21862                 ndr_print_uint32(ndr, "level", r->in.level);
21863                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21864                 ndr->depth++;
21865                 if (r->in.buffer) {
21866                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21867                 }
21868                 ndr->depth--;
21869                 ndr_print_uint32(ndr, "offered", r->in.offered);
21870                 ndr->depth--;
21871         }
21872         if (flags & NDR_OUT) {
21873                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
21874                 ndr->depth++;
21875                 ndr_print_ptr(ndr, "info", r->out.info);
21876                 ndr->depth++;
21877                 if (r->out.info) {
21878                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21879                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
21880                 }
21881                 ndr->depth--;
21882                 ndr_print_ptr(ndr, "needed", r->out.needed);
21883                 ndr->depth++;
21884                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21885                 ndr->depth--;
21886                 ndr_print_WERROR(ndr, "result", r->out.result);
21887                 ndr->depth--;
21888         }
21889         ndr->depth--;
21890 }
21891
21892 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
21893 {
21894         if (flags & NDR_IN) {
21895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21896                 if (r->in.server) {
21897                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21898                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21899                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21901                 }
21902                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21903                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21904                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21905                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21906                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21907                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21908                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21909                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21910         }
21911         if (flags & NDR_OUT) {
21912                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21913         }
21914         return NDR_ERR_SUCCESS;
21915 }
21916
21917 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
21918 {
21919         uint32_t _ptr_server;
21920         TALLOC_CTX *_mem_save_server_0;
21921         if (flags & NDR_IN) {
21922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21923                 if (_ptr_server) {
21924                         NDR_PULL_ALLOC(ndr, r->in.server);
21925                 } else {
21926                         r->in.server = NULL;
21927                 }
21928                 if (r->in.server) {
21929                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21930                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21931                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21932                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21933                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21934                                 return 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));
21935                         }
21936                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21937                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21939                 }
21940                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21941                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21942                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21943                         return 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));
21944                 }
21945                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21946                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21947                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
21948                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
21949                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
21950                         return 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));
21951                 }
21952                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
21953                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
21954         }
21955         if (flags & NDR_OUT) {
21956                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21957         }
21958         return NDR_ERR_SUCCESS;
21959 }
21960
21961 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
21962 {
21963         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
21964         ndr->depth++;
21965         if (flags & NDR_SET_VALUES) {
21966                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21967         }
21968         if (flags & NDR_IN) {
21969                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
21970                 ndr->depth++;
21971                 ndr_print_ptr(ndr, "server", r->in.server);
21972                 ndr->depth++;
21973                 if (r->in.server) {
21974                         ndr_print_string(ndr, "server", r->in.server);
21975                 }
21976                 ndr->depth--;
21977                 ndr_print_string(ndr, "architecture", r->in.architecture);
21978                 ndr_print_string(ndr, "driver", r->in.driver);
21979                 ndr->depth--;
21980         }
21981         if (flags & NDR_OUT) {
21982                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
21983                 ndr->depth++;
21984                 ndr_print_WERROR(ndr, "result", r->out.result);
21985                 ndr->depth--;
21986         }
21987         ndr->depth--;
21988 }
21989
21990 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
21991 {
21992         if (flags & NDR_IN) {
21993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21994                 if (r->in.server) {
21995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21998                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21999                 }
22000                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22001                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22002                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22003                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22004                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22005                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22006                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22007                 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));
22008                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22009                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22010                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22011                 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));
22012         }
22013         if (flags & NDR_OUT) {
22014                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22015         }
22016         return NDR_ERR_SUCCESS;
22017 }
22018
22019 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22020 {
22021         uint32_t _ptr_server;
22022         TALLOC_CTX *_mem_save_server_0;
22023         if (flags & NDR_IN) {
22024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22025                 if (_ptr_server) {
22026                         NDR_PULL_ALLOC(ndr, r->in.server);
22027                 } else {
22028                         r->in.server = NULL;
22029                 }
22030                 if (r->in.server) {
22031                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22032                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22033                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22034                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22035                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22036                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
22037                         }
22038                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22039                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22041                 }
22042                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22043                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22044                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22045                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
22046                 }
22047                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22048                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22049                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22050                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22051                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22052                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.path_name), ndr_get_array_length(ndr, &r->in.path_name));
22053                 }
22054                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22055                 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));
22056                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22057                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22058                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22059                         return 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));
22060                 }
22061                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22062                 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));
22063         }
22064         if (flags & NDR_OUT) {
22065                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22066         }
22067         return NDR_ERR_SUCCESS;
22068 }
22069
22070 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22071 {
22072         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22073         ndr->depth++;
22074         if (flags & NDR_SET_VALUES) {
22075                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22076         }
22077         if (flags & NDR_IN) {
22078                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22079                 ndr->depth++;
22080                 ndr_print_ptr(ndr, "server", r->in.server);
22081                 ndr->depth++;
22082                 if (r->in.server) {
22083                         ndr_print_string(ndr, "server", r->in.server);
22084                 }
22085                 ndr->depth--;
22086                 ndr_print_string(ndr, "architecture", r->in.architecture);
22087                 ndr_print_string(ndr, "path_name", r->in.path_name);
22088                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22089                 ndr->depth--;
22090         }
22091         if (flags & NDR_OUT) {
22092                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22093                 ndr->depth++;
22094                 ndr_print_WERROR(ndr, "result", r->out.result);
22095                 ndr->depth--;
22096         }
22097         ndr->depth--;
22098 }
22099
22100 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22101 {
22102         if (flags & NDR_IN) {
22103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22104                 if (r->in.servername) {
22105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22107                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22109                 }
22110                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22111                 if (r->in.environment) {
22112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22115                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22116                 }
22117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22119                 if (r->in.buffer) {
22120                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22121                 }
22122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22123         }
22124         if (flags & NDR_OUT) {
22125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22126                 if (r->out.info) {
22127                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22128                 }
22129                 if (r->out.needed == NULL) {
22130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22131                 }
22132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22133                 if (r->out.count == NULL) {
22134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22135                 }
22136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22138         }
22139         return NDR_ERR_SUCCESS;
22140 }
22141
22142 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22143 {
22144         uint32_t _ptr_servername;
22145         uint32_t _ptr_environment;
22146         uint32_t _ptr_buffer;
22147         uint32_t _ptr_info;
22148         TALLOC_CTX *_mem_save_servername_0;
22149         TALLOC_CTX *_mem_save_environment_0;
22150         TALLOC_CTX *_mem_save_buffer_0;
22151         TALLOC_CTX *_mem_save_info_0;
22152         TALLOC_CTX *_mem_save_needed_0;
22153         TALLOC_CTX *_mem_save_count_0;
22154         if (flags & NDR_IN) {
22155                 ZERO_STRUCT(r->out);
22156
22157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22158                 if (_ptr_servername) {
22159                         NDR_PULL_ALLOC(ndr, r->in.servername);
22160                 } else {
22161                         r->in.servername = NULL;
22162                 }
22163                 if (r->in.servername) {
22164                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22165                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22168                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22169                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
22170                         }
22171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22174                 }
22175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22176                 if (_ptr_environment) {
22177                         NDR_PULL_ALLOC(ndr, r->in.environment);
22178                 } else {
22179                         r->in.environment = NULL;
22180                 }
22181                 if (r->in.environment) {
22182                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22183                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22186                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22187                                 return 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));
22188                         }
22189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22192                 }
22193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22195                 if (_ptr_buffer) {
22196                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22197                 } else {
22198                         r->in.buffer = NULL;
22199                 }
22200                 if (r->in.buffer) {
22201                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22202                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22203                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22205                 }
22206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22207                 NDR_PULL_ALLOC(ndr, r->out.needed);
22208                 ZERO_STRUCTP(r->out.needed);
22209                 NDR_PULL_ALLOC(ndr, r->out.count);
22210                 ZERO_STRUCTP(r->out.count);
22211         }
22212         if (flags & NDR_OUT) {
22213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22214                 if (_ptr_info) {
22215                         NDR_PULL_ALLOC(ndr, r->out.info);
22216                 } else {
22217                         r->out.info = NULL;
22218                 }
22219                 if (r->out.info) {
22220                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22221                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22222                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22223                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22224                 }
22225                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22226                         NDR_PULL_ALLOC(ndr, r->out.needed);
22227                 }
22228                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22229                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22231                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22233                         NDR_PULL_ALLOC(ndr, r->out.count);
22234                 }
22235                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22236                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22239                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22240         }
22241         return NDR_ERR_SUCCESS;
22242 }
22243
22244 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22245 {
22246         uint32_t cntr_info_0;
22247         if (flags & NDR_IN) {
22248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22250         }
22251         if (flags & NDR_OUT) {
22252                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22253                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22254                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22255                 }
22256                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22257                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22258                 }
22259         }
22260         return NDR_ERR_SUCCESS;
22261 }
22262
22263 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22264 {
22265         uint32_t cntr_info_0;
22266         TALLOC_CTX *_mem_save_info_0;
22267         if (flags & NDR_IN) {
22268                 ZERO_STRUCT(r->out);
22269
22270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22272         }
22273         if (flags & NDR_OUT) {
22274                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22275                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22276                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22277                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22278                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22279                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22280                 }
22281                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22282                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22283                 }
22284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22285         }
22286         return NDR_ERR_SUCCESS;
22287 }
22288
22289 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22290 {
22291         uint32_t cntr_info_2;
22292         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22293         ndr->depth++;
22294         if (flags & NDR_SET_VALUES) {
22295                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22296         }
22297         if (flags & NDR_IN) {
22298                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22299                 ndr->depth++;
22300                 ndr_print_ptr(ndr, "servername", r->in.servername);
22301                 ndr->depth++;
22302                 if (r->in.servername) {
22303                         ndr_print_string(ndr, "servername", r->in.servername);
22304                 }
22305                 ndr->depth--;
22306                 ndr_print_ptr(ndr, "environment", r->in.environment);
22307                 ndr->depth++;
22308                 if (r->in.environment) {
22309                         ndr_print_string(ndr, "environment", r->in.environment);
22310                 }
22311                 ndr->depth--;
22312                 ndr_print_uint32(ndr, "level", r->in.level);
22313                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22314                 ndr->depth++;
22315                 if (r->in.buffer) {
22316                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22317                 }
22318                 ndr->depth--;
22319                 ndr_print_uint32(ndr, "offered", r->in.offered);
22320                 ndr->depth--;
22321         }
22322         if (flags & NDR_OUT) {
22323                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22324                 ndr->depth++;
22325                 ndr_print_ptr(ndr, "count", r->out.count);
22326                 ndr->depth++;
22327                 ndr_print_uint32(ndr, "count", *r->out.count);
22328                 ndr->depth--;
22329                 ndr_print_ptr(ndr, "info", r->out.info);
22330                 ndr->depth++;
22331                 ndr_print_ptr(ndr, "info", *r->out.info);
22332                 ndr->depth++;
22333                 if (*r->out.info) {
22334                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22335                         ndr->depth++;
22336                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22337                                 char *idx_2=NULL;
22338                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22339                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22340                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22341                                         free(idx_2);
22342                                 }
22343                         }
22344                         ndr->depth--;
22345                 }
22346                 ndr->depth--;
22347                 ndr->depth--;
22348                 ndr_print_ptr(ndr, "needed", r->out.needed);
22349                 ndr->depth++;
22350                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22351                 ndr->depth--;
22352                 ndr_print_WERROR(ndr, "result", r->out.result);
22353                 ndr->depth--;
22354         }
22355         ndr->depth--;
22356 }
22357
22358 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22359 {
22360         if (flags & NDR_IN) {
22361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22362                 if (r->in.server) {
22363                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22364                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22365                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22366                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22367                 }
22368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22369                 if (r->in.environment) {
22370                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22374                 }
22375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22377                 if (r->in.buffer) {
22378                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22379                 }
22380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22381         }
22382         if (flags & NDR_OUT) {
22383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22384                 if (r->out.info) {
22385                         {
22386                                 struct ndr_push *_ndr_info;
22387                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22388                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22389                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22390                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22391                         }
22392                 }
22393                 if (r->out.needed == NULL) {
22394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22395                 }
22396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22398         }
22399         return NDR_ERR_SUCCESS;
22400 }
22401
22402 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22403 {
22404         uint32_t _ptr_server;
22405         uint32_t _ptr_environment;
22406         uint32_t _ptr_buffer;
22407         uint32_t _ptr_info;
22408         TALLOC_CTX *_mem_save_server_0;
22409         TALLOC_CTX *_mem_save_environment_0;
22410         TALLOC_CTX *_mem_save_buffer_0;
22411         TALLOC_CTX *_mem_save_info_0;
22412         TALLOC_CTX *_mem_save_needed_0;
22413         if (flags & NDR_IN) {
22414                 ZERO_STRUCT(r->out);
22415
22416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22417                 if (_ptr_server) {
22418                         NDR_PULL_ALLOC(ndr, r->in.server);
22419                 } else {
22420                         r->in.server = NULL;
22421                 }
22422                 if (r->in.server) {
22423                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22424                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22427                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22428                                 return 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));
22429                         }
22430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22433                 }
22434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22435                 if (_ptr_environment) {
22436                         NDR_PULL_ALLOC(ndr, r->in.environment);
22437                 } else {
22438                         r->in.environment = NULL;
22439                 }
22440                 if (r->in.environment) {
22441                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22442                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22443                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22444                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22445                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22446                                 return 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));
22447                         }
22448                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22449                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22451                 }
22452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22454                 if (_ptr_buffer) {
22455                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22456                 } else {
22457                         r->in.buffer = NULL;
22458                 }
22459                 if (r->in.buffer) {
22460                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22461                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22462                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22464                 }
22465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22466                 NDR_PULL_ALLOC(ndr, r->out.needed);
22467                 ZERO_STRUCTP(r->out.needed);
22468         }
22469         if (flags & NDR_OUT) {
22470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22471                 if (_ptr_info) {
22472                         NDR_PULL_ALLOC(ndr, r->out.info);
22473                 } else {
22474                         r->out.info = NULL;
22475                 }
22476                 if (r->out.info) {
22477                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22478                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22479                         {
22480                                 struct ndr_pull *_ndr_info;
22481                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22482                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22483                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22484                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22485                         }
22486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22487                 }
22488                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22489                         NDR_PULL_ALLOC(ndr, r->out.needed);
22490                 }
22491                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22492                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22495                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22496         }
22497         return NDR_ERR_SUCCESS;
22498 }
22499
22500 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22501 {
22502         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22503         ndr->depth++;
22504         if (flags & NDR_SET_VALUES) {
22505                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22506         }
22507         if (flags & NDR_IN) {
22508                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22509                 ndr->depth++;
22510                 ndr_print_ptr(ndr, "server", r->in.server);
22511                 ndr->depth++;
22512                 if (r->in.server) {
22513                         ndr_print_string(ndr, "server", r->in.server);
22514                 }
22515                 ndr->depth--;
22516                 ndr_print_ptr(ndr, "environment", r->in.environment);
22517                 ndr->depth++;
22518                 if (r->in.environment) {
22519                         ndr_print_string(ndr, "environment", r->in.environment);
22520                 }
22521                 ndr->depth--;
22522                 ndr_print_uint32(ndr, "level", r->in.level);
22523                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22524                 ndr->depth++;
22525                 if (r->in.buffer) {
22526                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22527                 }
22528                 ndr->depth--;
22529                 ndr_print_uint32(ndr, "offered", r->in.offered);
22530                 ndr->depth--;
22531         }
22532         if (flags & NDR_OUT) {
22533                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22534                 ndr->depth++;
22535                 ndr_print_ptr(ndr, "info", r->out.info);
22536                 ndr->depth++;
22537                 if (r->out.info) {
22538                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22539                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
22540                 }
22541                 ndr->depth--;
22542                 ndr_print_ptr(ndr, "needed", r->out.needed);
22543                 ndr->depth++;
22544                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22545                 ndr->depth--;
22546                 ndr_print_WERROR(ndr, "result", r->out.result);
22547                 ndr->depth--;
22548         }
22549         ndr->depth--;
22550 }
22551
22552 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
22553 {
22554         if (flags & NDR_IN) {
22555                 if (r->in.handle == NULL) {
22556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22557                 }
22558                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22560                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22561                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22562         }
22563         if (flags & NDR_OUT) {
22564                 if (r->out.job_id == NULL) {
22565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22566                 }
22567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
22568                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22569         }
22570         return NDR_ERR_SUCCESS;
22571 }
22572
22573 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22574 {
22575         TALLOC_CTX *_mem_save_handle_0;
22576         TALLOC_CTX *_mem_save_job_id_0;
22577         if (flags & NDR_IN) {
22578                 ZERO_STRUCT(r->out);
22579
22580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22581                         NDR_PULL_ALLOC(ndr, r->in.handle);
22582                 }
22583                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22584                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22585                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22588                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22589                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22590                 NDR_PULL_ALLOC(ndr, r->out.job_id);
22591                 ZERO_STRUCTP(r->out.job_id);
22592         }
22593         if (flags & NDR_OUT) {
22594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22595                         NDR_PULL_ALLOC(ndr, r->out.job_id);
22596                 }
22597                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22598                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22602         }
22603         return NDR_ERR_SUCCESS;
22604 }
22605
22606 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22607 {
22608         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22609         ndr->depth++;
22610         if (flags & NDR_SET_VALUES) {
22611                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22612         }
22613         if (flags & NDR_IN) {
22614                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22615                 ndr->depth++;
22616                 ndr_print_ptr(ndr, "handle", r->in.handle);
22617                 ndr->depth++;
22618                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22619                 ndr->depth--;
22620                 ndr_print_uint32(ndr, "level", r->in.level);
22621                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22622                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22623                 ndr->depth--;
22624         }
22625         if (flags & NDR_OUT) {
22626                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22627                 ndr->depth++;
22628                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
22629                 ndr->depth++;
22630                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22631                 ndr->depth--;
22632                 ndr_print_WERROR(ndr, "result", r->out.result);
22633                 ndr->depth--;
22634         }
22635         ndr->depth--;
22636 }
22637
22638 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22639 {
22640         if (flags & NDR_IN) {
22641                 if (r->in.handle == NULL) {
22642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22643                 }
22644                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22645         }
22646         if (flags & NDR_OUT) {
22647                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22648         }
22649         return NDR_ERR_SUCCESS;
22650 }
22651
22652 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22653 {
22654         TALLOC_CTX *_mem_save_handle_0;
22655         if (flags & NDR_IN) {
22656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22657                         NDR_PULL_ALLOC(ndr, r->in.handle);
22658                 }
22659                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22661                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22663         }
22664         if (flags & NDR_OUT) {
22665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22666         }
22667         return NDR_ERR_SUCCESS;
22668 }
22669
22670 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22671 {
22672         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22673         ndr->depth++;
22674         if (flags & NDR_SET_VALUES) {
22675                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22676         }
22677         if (flags & NDR_IN) {
22678                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22679                 ndr->depth++;
22680                 ndr_print_ptr(ndr, "handle", r->in.handle);
22681                 ndr->depth++;
22682                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22683                 ndr->depth--;
22684                 ndr->depth--;
22685         }
22686         if (flags & NDR_OUT) {
22687                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
22688                 ndr->depth++;
22689                 ndr_print_WERROR(ndr, "result", r->out.result);
22690                 ndr->depth--;
22691         }
22692         ndr->depth--;
22693 }
22694
22695 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
22696 {
22697         if (flags & NDR_IN) {
22698                 if (r->in.handle == NULL) {
22699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22700                 }
22701                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22702                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
22704         }
22705         if (flags & NDR_OUT) {
22706                 if (r->out.num_written == NULL) {
22707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22708                 }
22709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
22710                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22711         }
22712         return NDR_ERR_SUCCESS;
22713 }
22714
22715 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
22716 {
22717         TALLOC_CTX *_mem_save_handle_0;
22718         TALLOC_CTX *_mem_save_num_written_0;
22719         if (flags & NDR_IN) {
22720                 ZERO_STRUCT(r->out);
22721
22722                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22723                         NDR_PULL_ALLOC(ndr, r->in.handle);
22724                 }
22725                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22726                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22727                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22728                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22729                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
22730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
22731                 NDR_PULL_ALLOC(ndr, r->out.num_written);
22732                 ZERO_STRUCTP(r->out.num_written);
22733         }
22734         if (flags & NDR_OUT) {
22735                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22736                         NDR_PULL_ALLOC(ndr, r->out.num_written);
22737                 }
22738                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
22739                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
22740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
22741                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
22742                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22743         }
22744         return NDR_ERR_SUCCESS;
22745 }
22746
22747 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
22748 {
22749         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
22750         ndr->depth++;
22751         if (flags & NDR_SET_VALUES) {
22752                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22753         }
22754         if (flags & NDR_IN) {
22755                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
22756                 ndr->depth++;
22757                 ndr_print_ptr(ndr, "handle", r->in.handle);
22758                 ndr->depth++;
22759                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22760                 ndr->depth--;
22761                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
22762                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
22763                 ndr->depth--;
22764         }
22765         if (flags & NDR_OUT) {
22766                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
22767                 ndr->depth++;
22768                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
22769                 ndr->depth++;
22770                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
22771                 ndr->depth--;
22772                 ndr_print_WERROR(ndr, "result", r->out.result);
22773                 ndr->depth--;
22774         }
22775         ndr->depth--;
22776 }
22777
22778 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22779 {
22780         if (flags & NDR_IN) {
22781                 if (r->in.handle == NULL) {
22782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22783                 }
22784                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22785         }
22786         if (flags & NDR_OUT) {
22787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22788         }
22789         return NDR_ERR_SUCCESS;
22790 }
22791
22792 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22793 {
22794         TALLOC_CTX *_mem_save_handle_0;
22795         if (flags & NDR_IN) {
22796                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22797                         NDR_PULL_ALLOC(ndr, r->in.handle);
22798                 }
22799                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22800                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22801                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22803         }
22804         if (flags & NDR_OUT) {
22805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22806         }
22807         return NDR_ERR_SUCCESS;
22808 }
22809
22810 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22811 {
22812         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22813         ndr->depth++;
22814         if (flags & NDR_SET_VALUES) {
22815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22816         }
22817         if (flags & NDR_IN) {
22818                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22819                 ndr->depth++;
22820                 ndr_print_ptr(ndr, "handle", r->in.handle);
22821                 ndr->depth++;
22822                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22823                 ndr->depth--;
22824                 ndr->depth--;
22825         }
22826         if (flags & NDR_OUT) {
22827                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22828                 ndr->depth++;
22829                 ndr_print_WERROR(ndr, "result", r->out.result);
22830                 ndr->depth--;
22831         }
22832         ndr->depth--;
22833 }
22834
22835 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22836 {
22837         if (flags & NDR_IN) {
22838                 if (r->in.handle == NULL) {
22839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22840                 }
22841                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22842         }
22843         if (flags & NDR_OUT) {
22844                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22845         }
22846         return NDR_ERR_SUCCESS;
22847 }
22848
22849 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
22850 {
22851         TALLOC_CTX *_mem_save_handle_0;
22852         if (flags & NDR_IN) {
22853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22854                         NDR_PULL_ALLOC(ndr, r->in.handle);
22855                 }
22856                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22857                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22858                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22860         }
22861         if (flags & NDR_OUT) {
22862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22863         }
22864         return NDR_ERR_SUCCESS;
22865 }
22866
22867 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
22868 {
22869         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
22870         ndr->depth++;
22871         if (flags & NDR_SET_VALUES) {
22872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22873         }
22874         if (flags & NDR_IN) {
22875                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
22876                 ndr->depth++;
22877                 ndr_print_ptr(ndr, "handle", r->in.handle);
22878                 ndr->depth++;
22879                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22880                 ndr->depth--;
22881                 ndr->depth--;
22882         }
22883         if (flags & NDR_OUT) {
22884                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
22885                 ndr->depth++;
22886                 ndr_print_WERROR(ndr, "result", r->out.result);
22887                 ndr->depth--;
22888         }
22889         ndr->depth--;
22890 }
22891
22892 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
22893 {
22894         if (flags & NDR_IN) {
22895                 if (r->in.handle == NULL) {
22896                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22897                 }
22898                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22900         }
22901         if (flags & NDR_OUT) {
22902                 if (r->out.data == NULL) {
22903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22904                 }
22905                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
22906                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
22907                 if (r->out._data_size == NULL) {
22908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22909                 }
22910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
22911                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22912         }
22913         return NDR_ERR_SUCCESS;
22914 }
22915
22916 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
22917 {
22918         TALLOC_CTX *_mem_save_handle_0;
22919         TALLOC_CTX *_mem_save__data_size_0;
22920         if (flags & NDR_IN) {
22921                 ZERO_STRUCT(r->out);
22922
22923                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22924                         NDR_PULL_ALLOC(ndr, r->in.handle);
22925                 }
22926                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22927                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22928                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22929                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
22931                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
22932                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
22933                 NDR_PULL_ALLOC(ndr, r->out._data_size);
22934                 ZERO_STRUCTP(r->out._data_size);
22935         }
22936         if (flags & NDR_OUT) {
22937                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
22938                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22939                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
22940                 }
22941                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
22942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22943                         NDR_PULL_ALLOC(ndr, r->out._data_size);
22944                 }
22945                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
22946                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
22947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
22948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
22949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22950                 if (r->out.data) {
22951                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
22952                 }
22953         }
22954         return NDR_ERR_SUCCESS;
22955 }
22956
22957 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
22958 {
22959         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
22960         ndr->depth++;
22961         if (flags & NDR_SET_VALUES) {
22962                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22963         }
22964         if (flags & NDR_IN) {
22965                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
22966                 ndr->depth++;
22967                 ndr_print_ptr(ndr, "handle", r->in.handle);
22968                 ndr->depth++;
22969                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22970                 ndr->depth--;
22971                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
22972                 ndr->depth--;
22973         }
22974         if (flags & NDR_OUT) {
22975                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
22976                 ndr->depth++;
22977                 ndr_print_ptr(ndr, "data", r->out.data);
22978                 ndr->depth++;
22979                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
22980                 ndr->depth--;
22981                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
22982                 ndr->depth++;
22983                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
22984                 ndr->depth--;
22985                 ndr_print_WERROR(ndr, "result", r->out.result);
22986                 ndr->depth--;
22987         }
22988         ndr->depth--;
22989 }
22990
22991 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
22992 {
22993         if (flags & NDR_IN) {
22994                 if (r->in.handle == NULL) {
22995                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22996                 }
22997                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22998         }
22999         if (flags & NDR_OUT) {
23000                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23001         }
23002         return NDR_ERR_SUCCESS;
23003 }
23004
23005 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23006 {
23007         TALLOC_CTX *_mem_save_handle_0;
23008         if (flags & NDR_IN) {
23009                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23010                         NDR_PULL_ALLOC(ndr, r->in.handle);
23011                 }
23012                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23013                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23014                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23016         }
23017         if (flags & NDR_OUT) {
23018                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23019         }
23020         return NDR_ERR_SUCCESS;
23021 }
23022
23023 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23024 {
23025         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23026         ndr->depth++;
23027         if (flags & NDR_SET_VALUES) {
23028                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23029         }
23030         if (flags & NDR_IN) {
23031                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23032                 ndr->depth++;
23033                 ndr_print_ptr(ndr, "handle", r->in.handle);
23034                 ndr->depth++;
23035                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23036                 ndr->depth--;
23037                 ndr->depth--;
23038         }
23039         if (flags & NDR_OUT) {
23040                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23041                 ndr->depth++;
23042                 ndr_print_WERROR(ndr, "result", r->out.result);
23043                 ndr->depth--;
23044         }
23045         ndr->depth--;
23046 }
23047
23048 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23049 {
23050         if (flags & NDR_IN) {
23051                 if (r->in.handle == NULL) {
23052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23053                 }
23054                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23057                 if (r->in.buffer) {
23058                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23059                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23060                 }
23061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23062         }
23063         if (flags & NDR_OUT) {
23064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23065                 if (r->out.buffer) {
23066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23067                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23068                 }
23069                 if (r->out.needed == NULL) {
23070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23071                 }
23072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23074         }
23075         return NDR_ERR_SUCCESS;
23076 }
23077
23078 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23079 {
23080         uint32_t _ptr_buffer;
23081         TALLOC_CTX *_mem_save_handle_0;
23082         TALLOC_CTX *_mem_save_buffer_0;
23083         TALLOC_CTX *_mem_save_needed_0;
23084         if (flags & NDR_IN) {
23085                 ZERO_STRUCT(r->out);
23086
23087                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23088                         NDR_PULL_ALLOC(ndr, r->in.handle);
23089                 }
23090                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23092                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23096                 if (_ptr_buffer) {
23097                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23098                 } else {
23099                         r->in.buffer = NULL;
23100                 }
23101                 if (r->in.buffer) {
23102                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23103                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23105                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23106                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23108                 }
23109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23110                 NDR_PULL_ALLOC(ndr, r->out.needed);
23111                 ZERO_STRUCTP(r->out.needed);
23112                 if (r->in.buffer) {
23113                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23114                 }
23115         }
23116         if (flags & NDR_OUT) {
23117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23118                 if (_ptr_buffer) {
23119                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23120                 } else {
23121                         r->out.buffer = NULL;
23122                 }
23123                 if (r->out.buffer) {
23124                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23125                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23126                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23127                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23128                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23130                 }
23131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23132                         NDR_PULL_ALLOC(ndr, r->out.needed);
23133                 }
23134                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23135                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23138                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23139                 if (r->out.buffer) {
23140                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23141                 }
23142         }
23143         return NDR_ERR_SUCCESS;
23144 }
23145
23146 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23147 {
23148         ndr_print_struct(ndr, name, "spoolss_AddJob");
23149         ndr->depth++;
23150         if (flags & NDR_SET_VALUES) {
23151                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23152         }
23153         if (flags & NDR_IN) {
23154                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23155                 ndr->depth++;
23156                 ndr_print_ptr(ndr, "handle", r->in.handle);
23157                 ndr->depth++;
23158                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23159                 ndr->depth--;
23160                 ndr_print_uint32(ndr, "level", r->in.level);
23161                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23162                 ndr->depth++;
23163                 if (r->in.buffer) {
23164                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23165                 }
23166                 ndr->depth--;
23167                 ndr_print_uint32(ndr, "offered", r->in.offered);
23168                 ndr->depth--;
23169         }
23170         if (flags & NDR_OUT) {
23171                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23172                 ndr->depth++;
23173                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23174                 ndr->depth++;
23175                 if (r->out.buffer) {
23176                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23177                 }
23178                 ndr->depth--;
23179                 ndr_print_ptr(ndr, "needed", r->out.needed);
23180                 ndr->depth++;
23181                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23182                 ndr->depth--;
23183                 ndr_print_WERROR(ndr, "result", r->out.result);
23184                 ndr->depth--;
23185         }
23186         ndr->depth--;
23187 }
23188
23189 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23190 {
23191         if (flags & NDR_IN) {
23192                 if (r->in.handle == NULL) {
23193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23194                 }
23195                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23197         }
23198         if (flags & NDR_OUT) {
23199                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23200         }
23201         return NDR_ERR_SUCCESS;
23202 }
23203
23204 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23205 {
23206         TALLOC_CTX *_mem_save_handle_0;
23207         if (flags & NDR_IN) {
23208                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23209                         NDR_PULL_ALLOC(ndr, r->in.handle);
23210                 }
23211                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23212                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23213                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23214                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23216         }
23217         if (flags & NDR_OUT) {
23218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23219         }
23220         return NDR_ERR_SUCCESS;
23221 }
23222
23223 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23224 {
23225         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23226         ndr->depth++;
23227         if (flags & NDR_SET_VALUES) {
23228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23229         }
23230         if (flags & NDR_IN) {
23231                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23232                 ndr->depth++;
23233                 ndr_print_ptr(ndr, "handle", r->in.handle);
23234                 ndr->depth++;
23235                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23236                 ndr->depth--;
23237                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23238                 ndr->depth--;
23239         }
23240         if (flags & NDR_OUT) {
23241                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23242                 ndr->depth++;
23243                 ndr_print_WERROR(ndr, "result", r->out.result);
23244                 ndr->depth--;
23245         }
23246         ndr->depth--;
23247 }
23248
23249 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
23250 {
23251         if (flags & NDR_IN) {
23252                 if (r->in.handle == NULL) {
23253                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23254                 }
23255                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23256                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23257                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23258                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23259                 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));
23260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23261         }
23262         if (flags & NDR_OUT) {
23263                 if (r->out.type == NULL) {
23264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23265                 }
23266                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23267                 if (r->out.data == NULL) {
23268                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23269                 }
23270                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
23271                 if (r->out.needed == NULL) {
23272                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23273                 }
23274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23275                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23276         }
23277         return NDR_ERR_SUCCESS;
23278 }
23279
23280 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
23281 {
23282         TALLOC_CTX *_mem_save_handle_0;
23283         TALLOC_CTX *_mem_save_type_0;
23284         TALLOC_CTX *_mem_save_data_0;
23285         TALLOC_CTX *_mem_save_needed_0;
23286         if (flags & NDR_IN) {
23287                 ZERO_STRUCT(r->out);
23288
23289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23290                         NDR_PULL_ALLOC(ndr, r->in.handle);
23291                 }
23292                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23293                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23294                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23296                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23297                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23298                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23299                         return 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));
23300                 }
23301                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23302                 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));
23303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23304                 NDR_PULL_ALLOC(ndr, r->out.type);
23305                 ZERO_STRUCTP(r->out.type);
23306                 NDR_PULL_ALLOC(ndr, r->out.data);
23307                 ZERO_STRUCTP(r->out.data);
23308                 NDR_PULL_ALLOC(ndr, r->out.needed);
23309                 ZERO_STRUCTP(r->out.needed);
23310         }
23311         if (flags & NDR_OUT) {
23312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23313                         NDR_PULL_ALLOC(ndr, r->out.type);
23314                 }
23315                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23316                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23317                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23319                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23320                         NDR_PULL_ALLOC(ndr, r->out.data);
23321                 }
23322                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23323                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23324                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23325                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23326                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23327                         NDR_PULL_ALLOC(ndr, r->out.needed);
23328                 }
23329                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23330                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23332                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23333                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23334         }
23335         return NDR_ERR_SUCCESS;
23336 }
23337
23338 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23339 {
23340         if (flags & NDR_IN) {
23341                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23342         }
23343         if (flags & NDR_OUT) {
23344                 if (r->out.data == NULL) {
23345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23346                 }
23347                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23348                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23349         }
23350         return NDR_ERR_SUCCESS;
23351 }
23352
23353 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23354 {
23355         TALLOC_CTX *_mem_save_data_0;
23356         if (flags & NDR_IN) {
23357                 ZERO_STRUCT(r->out);
23358
23359                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23360                 NDR_PULL_ALLOC(ndr, r->out.data);
23361                 ZERO_STRUCTP(r->out.data);
23362         }
23363         if (flags & NDR_OUT) {
23364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23365                         NDR_PULL_ALLOC(ndr, r->out.data);
23366                 }
23367                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23369                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23370                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23372         }
23373         return NDR_ERR_SUCCESS;
23374 }
23375
23376 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23377 {
23378         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23379         ndr->depth++;
23380         if (flags & NDR_SET_VALUES) {
23381                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23382         }
23383         if (flags & NDR_IN) {
23384                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23385                 ndr->depth++;
23386                 ndr_print_ptr(ndr, "handle", r->in.handle);
23387                 ndr->depth++;
23388                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23389                 ndr->depth--;
23390                 ndr_print_string(ndr, "value_name", r->in.value_name);
23391                 ndr_print_uint32(ndr, "offered", r->in.offered);
23392                 ndr->depth--;
23393         }
23394         if (flags & NDR_OUT) {
23395                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23396                 ndr->depth++;
23397                 ndr_print_ptr(ndr, "type", r->out.type);
23398                 ndr->depth++;
23399                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23400                 ndr->depth--;
23401                 ndr_print_ptr(ndr, "data", r->out.data);
23402                 ndr->depth++;
23403                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23404                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23405                 ndr->depth--;
23406                 ndr_print_ptr(ndr, "needed", r->out.needed);
23407                 ndr->depth++;
23408                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23409                 ndr->depth--;
23410                 ndr_print_WERROR(ndr, "result", r->out.result);
23411                 ndr->depth--;
23412         }
23413         ndr->depth--;
23414 }
23415
23416 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23417 {
23418         if (flags & NDR_IN) {
23419                 if (r->in.handle == NULL) {
23420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23421                 }
23422                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23423                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23424                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23425                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23426                 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));
23427                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23428                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
23430         }
23431         if (flags & NDR_OUT) {
23432                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23433         }
23434         return NDR_ERR_SUCCESS;
23435 }
23436
23437 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
23438 {
23439         if (flags & NDR_IN) {
23440                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23441         }
23442         if (flags & NDR_OUT) {
23443                 if (r->out.data == NULL) {
23444                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23445                 }
23446                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23447                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23448         }
23449         return NDR_ERR_SUCCESS;
23450 }
23451
23452 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23453 {
23454         TALLOC_CTX *_mem_save_handle_0;
23455         if (flags & NDR_IN) {
23456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23457                         NDR_PULL_ALLOC(ndr, r->in.handle);
23458                 }
23459                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23460                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23461                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23463                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23464                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23465                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23466                         return 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));
23467                 }
23468                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23469                 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));
23470                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23471                 {
23472                         struct ndr_pull *_ndr_data;
23473                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
23474                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
23475                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
23476                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
23477                 }
23478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
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_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23487 {
23488         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
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_SetPrinterData");
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_print_string(ndr, "value_name", r->in.value_name);
23501                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23502                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
23503                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
23504                 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);
23505                 ndr->depth--;
23506         }
23507         if (flags & NDR_OUT) {
23508                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23509                 ndr->depth++;
23510                 ndr_print_WERROR(ndr, "result", r->out.result);
23511                 ndr->depth--;
23512         }
23513         ndr->depth--;
23514 }
23515
23516 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23517 {
23518         if (flags & NDR_IN) {
23519         }
23520         if (flags & NDR_OUT) {
23521                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23522         }
23523         return NDR_ERR_SUCCESS;
23524 }
23525
23526 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23527 {
23528         if (flags & NDR_IN) {
23529         }
23530         if (flags & NDR_OUT) {
23531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23532         }
23533         return NDR_ERR_SUCCESS;
23534 }
23535
23536 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
23537 {
23538         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
23539         ndr->depth++;
23540         if (flags & NDR_SET_VALUES) {
23541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23542         }
23543         if (flags & NDR_IN) {
23544                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
23545                 ndr->depth++;
23546                 ndr->depth--;
23547         }
23548         if (flags & NDR_OUT) {
23549                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
23550                 ndr->depth++;
23551                 ndr_print_WERROR(ndr, "result", r->out.result);
23552                 ndr->depth--;
23553         }
23554         ndr->depth--;
23555 }
23556
23557 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
23558 {
23559         if (flags & NDR_IN) {
23560                 if (r->in.handle == NULL) {
23561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23562                 }
23563                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23564         }
23565         if (flags & NDR_OUT) {
23566                 if (r->out.handle == NULL) {
23567                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23568                 }
23569                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23570                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23571         }
23572         return NDR_ERR_SUCCESS;
23573 }
23574
23575 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23576 {
23577         TALLOC_CTX *_mem_save_handle_0;
23578         if (flags & NDR_IN) {
23579                 ZERO_STRUCT(r->out);
23580
23581                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23582                         NDR_PULL_ALLOC(ndr, r->in.handle);
23583                 }
23584                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23585                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23586                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23588                 NDR_PULL_ALLOC(ndr, r->out.handle);
23589                 *r->out.handle = *r->in.handle;
23590         }
23591         if (flags & NDR_OUT) {
23592                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23593                         NDR_PULL_ALLOC(ndr, r->out.handle);
23594                 }
23595                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23596                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23597                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23599                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23600         }
23601         return NDR_ERR_SUCCESS;
23602 }
23603
23604 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23605 {
23606         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23607         ndr->depth++;
23608         if (flags & NDR_SET_VALUES) {
23609                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23610         }
23611         if (flags & NDR_IN) {
23612                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23613                 ndr->depth++;
23614                 ndr_print_ptr(ndr, "handle", r->in.handle);
23615                 ndr->depth++;
23616                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23617                 ndr->depth--;
23618                 ndr->depth--;
23619         }
23620         if (flags & NDR_OUT) {
23621                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23622                 ndr->depth++;
23623                 ndr_print_ptr(ndr, "handle", r->out.handle);
23624                 ndr->depth++;
23625                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23626                 ndr->depth--;
23627                 ndr_print_WERROR(ndr, "result", r->out.result);
23628                 ndr->depth--;
23629         }
23630         ndr->depth--;
23631 }
23632
23633 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23634 {
23635         if (flags & NDR_IN) {
23636                 if (r->in.handle == NULL) {
23637                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23638                 }
23639                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23641                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23642                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23643         }
23644         if (flags & NDR_OUT) {
23645                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23646         }
23647         return NDR_ERR_SUCCESS;
23648 }
23649
23650 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23651 {
23652         TALLOC_CTX *_mem_save_handle_0;
23653         if (flags & NDR_IN) {
23654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23655                         NDR_PULL_ALLOC(ndr, r->in.handle);
23656                 }
23657                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23659                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23662                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23663                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23664         }
23665         if (flags & NDR_OUT) {
23666                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23667         }
23668         return NDR_ERR_SUCCESS;
23669 }
23670
23671 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23672 {
23673         ndr_print_struct(ndr, name, "spoolss_AddForm");
23674         ndr->depth++;
23675         if (flags & NDR_SET_VALUES) {
23676                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23677         }
23678         if (flags & NDR_IN) {
23679                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
23680                 ndr->depth++;
23681                 ndr_print_ptr(ndr, "handle", r->in.handle);
23682                 ndr->depth++;
23683                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23684                 ndr->depth--;
23685                 ndr_print_uint32(ndr, "level", r->in.level);
23686                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23687                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23688                 ndr->depth--;
23689         }
23690         if (flags & NDR_OUT) {
23691                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
23692                 ndr->depth++;
23693                 ndr_print_WERROR(ndr, "result", r->out.result);
23694                 ndr->depth--;
23695         }
23696         ndr->depth--;
23697 }
23698
23699 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
23700 {
23701         if (flags & NDR_IN) {
23702                 if (r->in.handle == NULL) {
23703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23704                 }
23705                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23706                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23707                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23708                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23709                 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));
23710         }
23711         if (flags & NDR_OUT) {
23712                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23713         }
23714         return NDR_ERR_SUCCESS;
23715 }
23716
23717 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
23718 {
23719         TALLOC_CTX *_mem_save_handle_0;
23720         if (flags & NDR_IN) {
23721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23722                         NDR_PULL_ALLOC(ndr, r->in.handle);
23723                 }
23724                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23725                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23726                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23727                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23728                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23729                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23730                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23731                         return 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));
23732                 }
23733                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23734                 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));
23735         }
23736         if (flags & NDR_OUT) {
23737                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23738         }
23739         return NDR_ERR_SUCCESS;
23740 }
23741
23742 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
23743 {
23744         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
23745         ndr->depth++;
23746         if (flags & NDR_SET_VALUES) {
23747                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23748         }
23749         if (flags & NDR_IN) {
23750                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
23751                 ndr->depth++;
23752                 ndr_print_ptr(ndr, "handle", r->in.handle);
23753                 ndr->depth++;
23754                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23755                 ndr->depth--;
23756                 ndr_print_string(ndr, "form_name", r->in.form_name);
23757                 ndr->depth--;
23758         }
23759         if (flags & NDR_OUT) {
23760                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
23761                 ndr->depth++;
23762                 ndr_print_WERROR(ndr, "result", r->out.result);
23763                 ndr->depth--;
23764         }
23765         ndr->depth--;
23766 }
23767
23768 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
23769 {
23770         if (flags & NDR_IN) {
23771                 if (r->in.handle == NULL) {
23772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23773                 }
23774                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23775                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23776                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23777                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23778                 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));
23779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23781                 if (r->in.buffer) {
23782                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23783                 }
23784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23785         }
23786         if (flags & NDR_OUT) {
23787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23788                 if (r->out.info) {
23789                         {
23790                                 struct ndr_push *_ndr_info;
23791                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23792                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23793                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23794                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23795                         }
23796                 }
23797                 if (r->out.needed == NULL) {
23798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23799                 }
23800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23801                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23802         }
23803         return NDR_ERR_SUCCESS;
23804 }
23805
23806 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23807 {
23808         uint32_t _ptr_buffer;
23809         uint32_t _ptr_info;
23810         TALLOC_CTX *_mem_save_handle_0;
23811         TALLOC_CTX *_mem_save_buffer_0;
23812         TALLOC_CTX *_mem_save_info_0;
23813         TALLOC_CTX *_mem_save_needed_0;
23814         if (flags & NDR_IN) {
23815                 ZERO_STRUCT(r->out);
23816
23817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23818                         NDR_PULL_ALLOC(ndr, r->in.handle);
23819                 }
23820                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23821                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23822                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23824                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23825                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23826                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23827                         return 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));
23828                 }
23829                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23830                 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));
23831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23833                 if (_ptr_buffer) {
23834                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23835                 } else {
23836                         r->in.buffer = NULL;
23837                 }
23838                 if (r->in.buffer) {
23839                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23840                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23841                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23842                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23843                 }
23844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23845                 NDR_PULL_ALLOC(ndr, r->out.needed);
23846                 ZERO_STRUCTP(r->out.needed);
23847         }
23848         if (flags & NDR_OUT) {
23849                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23850                 if (_ptr_info) {
23851                         NDR_PULL_ALLOC(ndr, r->out.info);
23852                 } else {
23853                         r->out.info = NULL;
23854                 }
23855                 if (r->out.info) {
23856                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23857                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23858                         {
23859                                 struct ndr_pull *_ndr_info;
23860                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23861                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23862                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23863                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23864                         }
23865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23866                 }
23867                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23868                         NDR_PULL_ALLOC(ndr, r->out.needed);
23869                 }
23870                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23871                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23873                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23874                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23875         }
23876         return NDR_ERR_SUCCESS;
23877 }
23878
23879 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23880 {
23881         ndr_print_struct(ndr, name, "spoolss_GetForm");
23882         ndr->depth++;
23883         if (flags & NDR_SET_VALUES) {
23884                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23885         }
23886         if (flags & NDR_IN) {
23887                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
23888                 ndr->depth++;
23889                 ndr_print_ptr(ndr, "handle", r->in.handle);
23890                 ndr->depth++;
23891                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23892                 ndr->depth--;
23893                 ndr_print_string(ndr, "form_name", r->in.form_name);
23894                 ndr_print_uint32(ndr, "level", r->in.level);
23895                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23896                 ndr->depth++;
23897                 if (r->in.buffer) {
23898                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23899                 }
23900                 ndr->depth--;
23901                 ndr_print_uint32(ndr, "offered", r->in.offered);
23902                 ndr->depth--;
23903         }
23904         if (flags & NDR_OUT) {
23905                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
23906                 ndr->depth++;
23907                 ndr_print_ptr(ndr, "info", r->out.info);
23908                 ndr->depth++;
23909                 if (r->out.info) {
23910                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23911                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
23912                 }
23913                 ndr->depth--;
23914                 ndr_print_ptr(ndr, "needed", r->out.needed);
23915                 ndr->depth++;
23916                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23917                 ndr->depth--;
23918                 ndr_print_WERROR(ndr, "result", r->out.result);
23919                 ndr->depth--;
23920         }
23921         ndr->depth--;
23922 }
23923
23924 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
23925 {
23926         if (flags & NDR_IN) {
23927                 if (r->in.handle == NULL) {
23928                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23929                 }
23930                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23931                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23932                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23933                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23934                 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));
23935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23936                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23937                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23938         }
23939         if (flags & NDR_OUT) {
23940                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23941         }
23942         return NDR_ERR_SUCCESS;
23943 }
23944
23945 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
23946 {
23947         TALLOC_CTX *_mem_save_handle_0;
23948         if (flags & NDR_IN) {
23949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23950                         NDR_PULL_ALLOC(ndr, r->in.handle);
23951                 }
23952                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23953                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23954                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23956                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23957                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23958                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23959                         return 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));
23960                 }
23961                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23962                 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));
23963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23964                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23965                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23966         }
23967         if (flags & NDR_OUT) {
23968                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23969         }
23970         return NDR_ERR_SUCCESS;
23971 }
23972
23973 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
23974 {
23975         ndr_print_struct(ndr, name, "spoolss_SetForm");
23976         ndr->depth++;
23977         if (flags & NDR_SET_VALUES) {
23978                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23979         }
23980         if (flags & NDR_IN) {
23981                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
23982                 ndr->depth++;
23983                 ndr_print_ptr(ndr, "handle", r->in.handle);
23984                 ndr->depth++;
23985                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23986                 ndr->depth--;
23987                 ndr_print_string(ndr, "form_name", r->in.form_name);
23988                 ndr_print_uint32(ndr, "level", r->in.level);
23989                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23990                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23991                 ndr->depth--;
23992         }
23993         if (flags & NDR_OUT) {
23994                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
23995                 ndr->depth++;
23996                 ndr_print_WERROR(ndr, "result", r->out.result);
23997                 ndr->depth--;
23998         }
23999         ndr->depth--;
24000 }
24001
24002 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24003 {
24004         if (flags & NDR_IN) {
24005                 if (r->in.handle == NULL) {
24006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24007                 }
24008                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24011                 if (r->in.buffer) {
24012                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24013                 }
24014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24015         }
24016         if (flags & NDR_OUT) {
24017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24018                 if (r->out.info) {
24019                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24020                 }
24021                 if (r->out.needed == NULL) {
24022                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24023                 }
24024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24025                 if (r->out.count == NULL) {
24026                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24027                 }
24028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24029                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24030         }
24031         return NDR_ERR_SUCCESS;
24032 }
24033
24034 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24035 {
24036         uint32_t _ptr_buffer;
24037         uint32_t _ptr_info;
24038         TALLOC_CTX *_mem_save_handle_0;
24039         TALLOC_CTX *_mem_save_buffer_0;
24040         TALLOC_CTX *_mem_save_info_0;
24041         TALLOC_CTX *_mem_save_needed_0;
24042         TALLOC_CTX *_mem_save_count_0;
24043         if (flags & NDR_IN) {
24044                 ZERO_STRUCT(r->out);
24045
24046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24047                         NDR_PULL_ALLOC(ndr, r->in.handle);
24048                 }
24049                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24050                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24051                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24055                 if (_ptr_buffer) {
24056                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24057                 } else {
24058                         r->in.buffer = NULL;
24059                 }
24060                 if (r->in.buffer) {
24061                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24062                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24063                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24064                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24065                 }
24066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24067                 NDR_PULL_ALLOC(ndr, r->out.needed);
24068                 ZERO_STRUCTP(r->out.needed);
24069                 NDR_PULL_ALLOC(ndr, r->out.count);
24070                 ZERO_STRUCTP(r->out.count);
24071         }
24072         if (flags & NDR_OUT) {
24073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24074                 if (_ptr_info) {
24075                         NDR_PULL_ALLOC(ndr, r->out.info);
24076                 } else {
24077                         r->out.info = NULL;
24078                 }
24079                 if (r->out.info) {
24080                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24081                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24082                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24084                 }
24085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24086                         NDR_PULL_ALLOC(ndr, r->out.needed);
24087                 }
24088                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24089                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24092                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24093                         NDR_PULL_ALLOC(ndr, r->out.count);
24094                 }
24095                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24096                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24099                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24100         }
24101         return NDR_ERR_SUCCESS;
24102 }
24103
24104 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24105 {
24106         uint32_t cntr_info_0;
24107         if (flags & NDR_IN) {
24108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24110         }
24111         if (flags & NDR_OUT) {
24112                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24113                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24114                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24115                 }
24116                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24117                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24118                 }
24119         }
24120         return NDR_ERR_SUCCESS;
24121 }
24122
24123 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24124 {
24125         uint32_t cntr_info_0;
24126         TALLOC_CTX *_mem_save_info_0;
24127         if (flags & NDR_IN) {
24128                 ZERO_STRUCT(r->out);
24129
24130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24132         }
24133         if (flags & NDR_OUT) {
24134                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24135                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24136                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24137                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24138                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24139                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24140                 }
24141                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24142                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24143                 }
24144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24145         }
24146         return NDR_ERR_SUCCESS;
24147 }
24148
24149 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24150 {
24151         uint32_t cntr_info_2;
24152         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24153         ndr->depth++;
24154         if (flags & NDR_SET_VALUES) {
24155                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24156         }
24157         if (flags & NDR_IN) {
24158                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24159                 ndr->depth++;
24160                 ndr_print_ptr(ndr, "handle", r->in.handle);
24161                 ndr->depth++;
24162                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24163                 ndr->depth--;
24164                 ndr_print_uint32(ndr, "level", r->in.level);
24165                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24166                 ndr->depth++;
24167                 if (r->in.buffer) {
24168                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24169                 }
24170                 ndr->depth--;
24171                 ndr_print_uint32(ndr, "offered", r->in.offered);
24172                 ndr->depth--;
24173         }
24174         if (flags & NDR_OUT) {
24175                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24176                 ndr->depth++;
24177                 ndr_print_ptr(ndr, "count", r->out.count);
24178                 ndr->depth++;
24179                 ndr_print_uint32(ndr, "count", *r->out.count);
24180                 ndr->depth--;
24181                 ndr_print_ptr(ndr, "info", r->out.info);
24182                 ndr->depth++;
24183                 ndr_print_ptr(ndr, "info", *r->out.info);
24184                 ndr->depth++;
24185                 if (*r->out.info) {
24186                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24187                         ndr->depth++;
24188                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24189                                 char *idx_2=NULL;
24190                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24191                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24192                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24193                                         free(idx_2);
24194                                 }
24195                         }
24196                         ndr->depth--;
24197                 }
24198                 ndr->depth--;
24199                 ndr->depth--;
24200                 ndr_print_ptr(ndr, "needed", r->out.needed);
24201                 ndr->depth++;
24202                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24203                 ndr->depth--;
24204                 ndr_print_WERROR(ndr, "result", r->out.result);
24205                 ndr->depth--;
24206         }
24207         ndr->depth--;
24208 }
24209
24210 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24211 {
24212         if (flags & NDR_IN) {
24213                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24214                 if (r->in.servername) {
24215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24218                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24219                 }
24220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24221                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24222                 if (r->in.buffer) {
24223                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24224                 }
24225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24226         }
24227         if (flags & NDR_OUT) {
24228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24229                 if (r->out.info) {
24230                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24231                 }
24232                 if (r->out.needed == NULL) {
24233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24234                 }
24235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24236                 if (r->out.count == NULL) {
24237                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24238                 }
24239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24240                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24241         }
24242         return NDR_ERR_SUCCESS;
24243 }
24244
24245 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24246 {
24247         uint32_t _ptr_servername;
24248         uint32_t _ptr_buffer;
24249         uint32_t _ptr_info;
24250         TALLOC_CTX *_mem_save_servername_0;
24251         TALLOC_CTX *_mem_save_buffer_0;
24252         TALLOC_CTX *_mem_save_info_0;
24253         TALLOC_CTX *_mem_save_needed_0;
24254         TALLOC_CTX *_mem_save_count_0;
24255         if (flags & NDR_IN) {
24256                 ZERO_STRUCT(r->out);
24257
24258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24259                 if (_ptr_servername) {
24260                         NDR_PULL_ALLOC(ndr, r->in.servername);
24261                 } else {
24262                         r->in.servername = NULL;
24263                 }
24264                 if (r->in.servername) {
24265                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24266                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24269                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24270                                 return 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));
24271                         }
24272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24275                 }
24276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24277                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24278                 if (_ptr_buffer) {
24279                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24280                 } else {
24281                         r->in.buffer = NULL;
24282                 }
24283                 if (r->in.buffer) {
24284                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24285                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24286                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24288                 }
24289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24290                 NDR_PULL_ALLOC(ndr, r->out.needed);
24291                 ZERO_STRUCTP(r->out.needed);
24292                 NDR_PULL_ALLOC(ndr, r->out.count);
24293                 ZERO_STRUCTP(r->out.count);
24294         }
24295         if (flags & NDR_OUT) {
24296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24297                 if (_ptr_info) {
24298                         NDR_PULL_ALLOC(ndr, r->out.info);
24299                 } else {
24300                         r->out.info = NULL;
24301                 }
24302                 if (r->out.info) {
24303                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24304                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24305                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24307                 }
24308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24309                         NDR_PULL_ALLOC(ndr, r->out.needed);
24310                 }
24311                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24315                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24316                         NDR_PULL_ALLOC(ndr, r->out.count);
24317                 }
24318                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24319                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24321                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24322                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24323         }
24324         return NDR_ERR_SUCCESS;
24325 }
24326
24327 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24328 {
24329         uint32_t cntr_info_0;
24330         if (flags & NDR_IN) {
24331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24333         }
24334         if (flags & NDR_OUT) {
24335                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24336                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24337                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24338                 }
24339                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24340                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24341                 }
24342         }
24343         return NDR_ERR_SUCCESS;
24344 }
24345
24346 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24347 {
24348         uint32_t cntr_info_0;
24349         TALLOC_CTX *_mem_save_info_0;
24350         if (flags & NDR_IN) {
24351                 ZERO_STRUCT(r->out);
24352
24353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24355         }
24356         if (flags & NDR_OUT) {
24357                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24358                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24359                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24360                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24361                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24362                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24363                 }
24364                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24365                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24366                 }
24367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24368         }
24369         return NDR_ERR_SUCCESS;
24370 }
24371
24372 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24373 {
24374         uint32_t cntr_info_2;
24375         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24376         ndr->depth++;
24377         if (flags & NDR_SET_VALUES) {
24378                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24379         }
24380         if (flags & NDR_IN) {
24381                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24382                 ndr->depth++;
24383                 ndr_print_ptr(ndr, "servername", r->in.servername);
24384                 ndr->depth++;
24385                 if (r->in.servername) {
24386                         ndr_print_string(ndr, "servername", r->in.servername);
24387                 }
24388                 ndr->depth--;
24389                 ndr_print_uint32(ndr, "level", r->in.level);
24390                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24391                 ndr->depth++;
24392                 if (r->in.buffer) {
24393                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24394                 }
24395                 ndr->depth--;
24396                 ndr_print_uint32(ndr, "offered", r->in.offered);
24397                 ndr->depth--;
24398         }
24399         if (flags & NDR_OUT) {
24400                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24401                 ndr->depth++;
24402                 ndr_print_ptr(ndr, "count", r->out.count);
24403                 ndr->depth++;
24404                 ndr_print_uint32(ndr, "count", *r->out.count);
24405                 ndr->depth--;
24406                 ndr_print_ptr(ndr, "info", r->out.info);
24407                 ndr->depth++;
24408                 ndr_print_ptr(ndr, "info", *r->out.info);
24409                 ndr->depth++;
24410                 if (*r->out.info) {
24411                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24412                         ndr->depth++;
24413                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24414                                 char *idx_2=NULL;
24415                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24416                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24417                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24418                                         free(idx_2);
24419                                 }
24420                         }
24421                         ndr->depth--;
24422                 }
24423                 ndr->depth--;
24424                 ndr->depth--;
24425                 ndr_print_ptr(ndr, "needed", r->out.needed);
24426                 ndr->depth++;
24427                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24428                 ndr->depth--;
24429                 ndr_print_WERROR(ndr, "result", r->out.result);
24430                 ndr->depth--;
24431         }
24432         ndr->depth--;
24433 }
24434
24435 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24436 {
24437         if (flags & NDR_IN) {
24438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24439                 if (r->in.servername) {
24440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24444                 }
24445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24447                 if (r->in.buffer) {
24448                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24449                 }
24450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24451         }
24452         if (flags & NDR_OUT) {
24453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24454                 if (r->out.info) {
24455                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24456                 }
24457                 if (r->out.needed == NULL) {
24458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24459                 }
24460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24461                 if (r->out.count == NULL) {
24462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24463                 }
24464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24465                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24466         }
24467         return NDR_ERR_SUCCESS;
24468 }
24469
24470 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24471 {
24472         uint32_t _ptr_servername;
24473         uint32_t _ptr_buffer;
24474         uint32_t _ptr_info;
24475         TALLOC_CTX *_mem_save_servername_0;
24476         TALLOC_CTX *_mem_save_buffer_0;
24477         TALLOC_CTX *_mem_save_info_0;
24478         TALLOC_CTX *_mem_save_needed_0;
24479         TALLOC_CTX *_mem_save_count_0;
24480         if (flags & NDR_IN) {
24481                 ZERO_STRUCT(r->out);
24482
24483                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24484                 if (_ptr_servername) {
24485                         NDR_PULL_ALLOC(ndr, r->in.servername);
24486                 } else {
24487                         r->in.servername = NULL;
24488                 }
24489                 if (r->in.servername) {
24490                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24491                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24492                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24493                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24494                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24495                                 return 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));
24496                         }
24497                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24498                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24499                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24500                 }
24501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24503                 if (_ptr_buffer) {
24504                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24505                 } else {
24506                         r->in.buffer = NULL;
24507                 }
24508                 if (r->in.buffer) {
24509                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24510                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24511                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24513                 }
24514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24515                 NDR_PULL_ALLOC(ndr, r->out.needed);
24516                 ZERO_STRUCTP(r->out.needed);
24517                 NDR_PULL_ALLOC(ndr, r->out.count);
24518                 ZERO_STRUCTP(r->out.count);
24519         }
24520         if (flags & NDR_OUT) {
24521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24522                 if (_ptr_info) {
24523                         NDR_PULL_ALLOC(ndr, r->out.info);
24524                 } else {
24525                         r->out.info = NULL;
24526                 }
24527                 if (r->out.info) {
24528                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24529                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24530                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24532                 }
24533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24534                         NDR_PULL_ALLOC(ndr, r->out.needed);
24535                 }
24536                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24537                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24541                         NDR_PULL_ALLOC(ndr, r->out.count);
24542                 }
24543                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24544                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24547                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24548         }
24549         return NDR_ERR_SUCCESS;
24550 }
24551
24552 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
24553 {
24554         uint32_t cntr_info_0;
24555         if (flags & NDR_IN) {
24556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24558         }
24559         if (flags & NDR_OUT) {
24560                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24561                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24562                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24563                 }
24564                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24565                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24566                 }
24567         }
24568         return NDR_ERR_SUCCESS;
24569 }
24570
24571 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24572 {
24573         uint32_t cntr_info_0;
24574         TALLOC_CTX *_mem_save_info_0;
24575         if (flags & NDR_IN) {
24576                 ZERO_STRUCT(r->out);
24577
24578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24580         }
24581         if (flags & NDR_OUT) {
24582                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24583                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24584                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24585                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24586                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24587                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24588                 }
24589                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24590                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24591                 }
24592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24593         }
24594         return NDR_ERR_SUCCESS;
24595 }
24596
24597 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24598 {
24599         uint32_t cntr_info_2;
24600         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24601         ndr->depth++;
24602         if (flags & NDR_SET_VALUES) {
24603                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24604         }
24605         if (flags & NDR_IN) {
24606                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24607                 ndr->depth++;
24608                 ndr_print_ptr(ndr, "servername", r->in.servername);
24609                 ndr->depth++;
24610                 if (r->in.servername) {
24611                         ndr_print_string(ndr, "servername", r->in.servername);
24612                 }
24613                 ndr->depth--;
24614                 ndr_print_uint32(ndr, "level", r->in.level);
24615                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24616                 ndr->depth++;
24617                 if (r->in.buffer) {
24618                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24619                 }
24620                 ndr->depth--;
24621                 ndr_print_uint32(ndr, "offered", r->in.offered);
24622                 ndr->depth--;
24623         }
24624         if (flags & NDR_OUT) {
24625                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24626                 ndr->depth++;
24627                 ndr_print_ptr(ndr, "count", r->out.count);
24628                 ndr->depth++;
24629                 ndr_print_uint32(ndr, "count", *r->out.count);
24630                 ndr->depth--;
24631                 ndr_print_ptr(ndr, "info", r->out.info);
24632                 ndr->depth++;
24633                 ndr_print_ptr(ndr, "info", *r->out.info);
24634                 ndr->depth++;
24635                 if (*r->out.info) {
24636                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24637                         ndr->depth++;
24638                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24639                                 char *idx_2=NULL;
24640                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24641                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24642                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24643                                         free(idx_2);
24644                                 }
24645                         }
24646                         ndr->depth--;
24647                 }
24648                 ndr->depth--;
24649                 ndr->depth--;
24650                 ndr_print_ptr(ndr, "needed", r->out.needed);
24651                 ndr->depth++;
24652                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24653                 ndr->depth--;
24654                 ndr_print_WERROR(ndr, "result", r->out.result);
24655                 ndr->depth--;
24656         }
24657         ndr->depth--;
24658 }
24659
24660 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24661 {
24662         if (flags & NDR_IN) {
24663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24664                 if (r->in.server_name) {
24665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24668                         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));
24669                 }
24670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24671                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24672                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24673                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24674                 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));
24675         }
24676         if (flags & NDR_OUT) {
24677                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24678         }
24679         return NDR_ERR_SUCCESS;
24680 }
24681
24682 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
24683 {
24684         uint32_t _ptr_server_name;
24685         TALLOC_CTX *_mem_save_server_name_0;
24686         if (flags & NDR_IN) {
24687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
24688                 if (_ptr_server_name) {
24689                         NDR_PULL_ALLOC(ndr, r->in.server_name);
24690                 } else {
24691                         r->in.server_name = NULL;
24692                 }
24693                 if (r->in.server_name) {
24694                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24695                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
24696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24698                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24699                                 return 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));
24700                         }
24701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24702                         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));
24703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
24704                 }
24705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
24706                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
24707                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
24708                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
24709                         return 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));
24710                 }
24711                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
24712                 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));
24713         }
24714         if (flags & NDR_OUT) {
24715                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24716         }
24717         return NDR_ERR_SUCCESS;
24718 }
24719
24720 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
24721 {
24722         ndr_print_struct(ndr, name, "spoolss_AddPort");
24723         ndr->depth++;
24724         if (flags & NDR_SET_VALUES) {
24725                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24726         }
24727         if (flags & NDR_IN) {
24728                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
24729                 ndr->depth++;
24730                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
24731                 ndr->depth++;
24732                 if (r->in.server_name) {
24733                         ndr_print_string(ndr, "server_name", r->in.server_name);
24734                 }
24735                 ndr->depth--;
24736                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
24737                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
24738                 ndr->depth--;
24739         }
24740         if (flags & NDR_OUT) {
24741                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
24742                 ndr->depth++;
24743                 ndr_print_WERROR(ndr, "result", r->out.result);
24744                 ndr->depth--;
24745         }
24746         ndr->depth--;
24747 }
24748
24749 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
24750 {
24751         if (flags & NDR_IN) {
24752         }
24753         if (flags & NDR_OUT) {
24754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24755         }
24756         return NDR_ERR_SUCCESS;
24757 }
24758
24759 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
24760 {
24761         if (flags & NDR_IN) {
24762         }
24763         if (flags & NDR_OUT) {
24764                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24765         }
24766         return NDR_ERR_SUCCESS;
24767 }
24768
24769 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
24770 {
24771         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
24772         ndr->depth++;
24773         if (flags & NDR_SET_VALUES) {
24774                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24775         }
24776         if (flags & NDR_IN) {
24777                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24778                 ndr->depth++;
24779                 ndr->depth--;
24780         }
24781         if (flags & NDR_OUT) {
24782                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24783                 ndr->depth++;
24784                 ndr_print_WERROR(ndr, "result", r->out.result);
24785                 ndr->depth--;
24786         }
24787         ndr->depth--;
24788 }
24789
24790 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24791 {
24792         if (flags & NDR_IN) {
24793         }
24794         if (flags & NDR_OUT) {
24795                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24796         }
24797         return NDR_ERR_SUCCESS;
24798 }
24799
24800 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24801 {
24802         if (flags & NDR_IN) {
24803         }
24804         if (flags & NDR_OUT) {
24805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24806         }
24807         return NDR_ERR_SUCCESS;
24808 }
24809
24810 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24811 {
24812         ndr_print_struct(ndr, name, "spoolss_DeletePort");
24813         ndr->depth++;
24814         if (flags & NDR_SET_VALUES) {
24815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24816         }
24817         if (flags & NDR_IN) {
24818                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24819                 ndr->depth++;
24820                 ndr->depth--;
24821         }
24822         if (flags & NDR_OUT) {
24823                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24824                 ndr->depth++;
24825                 ndr_print_WERROR(ndr, "result", r->out.result);
24826                 ndr->depth--;
24827         }
24828         ndr->depth--;
24829 }
24830
24831 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24832 {
24833         if (flags & NDR_IN) {
24834                 if (r->in.handle == NULL) {
24835                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24836                 }
24837                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24838                 if (r->in.devmode_ctr == NULL) {
24839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24840                 }
24841                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24842         }
24843         if (flags & NDR_OUT) {
24844                 if (r->out.gdi_handle == NULL) {
24845                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24846                 }
24847                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24848                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24849         }
24850         return NDR_ERR_SUCCESS;
24851 }
24852
24853 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24854 {
24855         TALLOC_CTX *_mem_save_handle_0;
24856         TALLOC_CTX *_mem_save_gdi_handle_0;
24857         TALLOC_CTX *_mem_save_devmode_ctr_0;
24858         if (flags & NDR_IN) {
24859                 ZERO_STRUCT(r->out);
24860
24861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24862                         NDR_PULL_ALLOC(ndr, r->in.handle);
24863                 }
24864                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24865                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24866                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24869                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24870                 }
24871                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24872                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24873                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24874                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24875                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24876                 ZERO_STRUCTP(r->out.gdi_handle);
24877         }
24878         if (flags & NDR_OUT) {
24879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24880                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24881                 }
24882                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24883                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24884                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24887         }
24888         return NDR_ERR_SUCCESS;
24889 }
24890
24891 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
24892 {
24893         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
24894         ndr->depth++;
24895         if (flags & NDR_SET_VALUES) {
24896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24897         }
24898         if (flags & NDR_IN) {
24899                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
24900                 ndr->depth++;
24901                 ndr_print_ptr(ndr, "handle", r->in.handle);
24902                 ndr->depth++;
24903                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24904                 ndr->depth--;
24905                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24906                 ndr->depth++;
24907                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24908                 ndr->depth--;
24909                 ndr->depth--;
24910         }
24911         if (flags & NDR_OUT) {
24912                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
24913                 ndr->depth++;
24914                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24915                 ndr->depth++;
24916                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24917                 ndr->depth--;
24918                 ndr_print_WERROR(ndr, "result", r->out.result);
24919                 ndr->depth--;
24920         }
24921         ndr->depth--;
24922 }
24923
24924 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24925 {
24926         if (flags & NDR_IN) {
24927         }
24928         if (flags & NDR_OUT) {
24929                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24930         }
24931         return NDR_ERR_SUCCESS;
24932 }
24933
24934 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
24935 {
24936         if (flags & NDR_IN) {
24937         }
24938         if (flags & NDR_OUT) {
24939                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24940         }
24941         return NDR_ERR_SUCCESS;
24942 }
24943
24944 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24945 {
24946         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
24947         ndr->depth++;
24948         if (flags & NDR_SET_VALUES) {
24949                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24950         }
24951         if (flags & NDR_IN) {
24952                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
24953                 ndr->depth++;
24954                 ndr->depth--;
24955         }
24956         if (flags & NDR_OUT) {
24957                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
24958                 ndr->depth++;
24959                 ndr_print_WERROR(ndr, "result", r->out.result);
24960                 ndr->depth--;
24961         }
24962         ndr->depth--;
24963 }
24964
24965 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
24966 {
24967         if (flags & NDR_IN) {
24968                 if (r->in.gdi_handle == NULL) {
24969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24970                 }
24971                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24972         }
24973         if (flags & NDR_OUT) {
24974                 if (r->out.gdi_handle == NULL) {
24975                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24976                 }
24977                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24978                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24979         }
24980         return NDR_ERR_SUCCESS;
24981 }
24982
24983 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
24984 {
24985         TALLOC_CTX *_mem_save_gdi_handle_0;
24986         if (flags & NDR_IN) {
24987                 ZERO_STRUCT(r->out);
24988
24989                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24990                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
24991                 }
24992                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24993                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24994                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24995                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24996                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24997                 *r->out.gdi_handle = *r->in.gdi_handle;
24998         }
24999         if (flags & NDR_OUT) {
25000                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25001                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25002                 }
25003                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25004                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25005                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25006                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25007                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25008         }
25009         return NDR_ERR_SUCCESS;
25010 }
25011
25012 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25013 {
25014         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25015         ndr->depth++;
25016         if (flags & NDR_SET_VALUES) {
25017                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25018         }
25019         if (flags & NDR_IN) {
25020                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25021                 ndr->depth++;
25022                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25023                 ndr->depth++;
25024                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25025                 ndr->depth--;
25026                 ndr->depth--;
25027         }
25028         if (flags & NDR_OUT) {
25029                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25030                 ndr->depth++;
25031                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25032                 ndr->depth++;
25033                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25034                 ndr->depth--;
25035                 ndr_print_WERROR(ndr, "result", r->out.result);
25036                 ndr->depth--;
25037         }
25038         ndr->depth--;
25039 }
25040
25041 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25042 {
25043         if (flags & NDR_IN) {
25044         }
25045         if (flags & NDR_OUT) {
25046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25047         }
25048         return NDR_ERR_SUCCESS;
25049 }
25050
25051 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25052 {
25053         if (flags & NDR_IN) {
25054         }
25055         if (flags & NDR_OUT) {
25056                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25057         }
25058         return NDR_ERR_SUCCESS;
25059 }
25060
25061 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25062 {
25063         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
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_AddPrinterConnection");
25070                 ndr->depth++;
25071                 ndr->depth--;
25072         }
25073         if (flags & NDR_OUT) {
25074                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25075                 ndr->depth++;
25076                 ndr_print_WERROR(ndr, "result", r->out.result);
25077                 ndr->depth--;
25078         }
25079         ndr->depth--;
25080 }
25081
25082 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25083 {
25084         if (flags & NDR_IN) {
25085         }
25086         if (flags & NDR_OUT) {
25087                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25088         }
25089         return NDR_ERR_SUCCESS;
25090 }
25091
25092 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25093 {
25094         if (flags & NDR_IN) {
25095         }
25096         if (flags & NDR_OUT) {
25097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25098         }
25099         return NDR_ERR_SUCCESS;
25100 }
25101
25102 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25103 {
25104         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25105         ndr->depth++;
25106         if (flags & NDR_SET_VALUES) {
25107                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25108         }
25109         if (flags & NDR_IN) {
25110                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25111                 ndr->depth++;
25112                 ndr->depth--;
25113         }
25114         if (flags & NDR_OUT) {
25115                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
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_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25124 {
25125         if (flags & NDR_IN) {
25126         }
25127         if (flags & NDR_OUT) {
25128                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25129         }
25130         return NDR_ERR_SUCCESS;
25131 }
25132
25133 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25134 {
25135         if (flags & NDR_IN) {
25136         }
25137         if (flags & NDR_OUT) {
25138                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25139         }
25140         return NDR_ERR_SUCCESS;
25141 }
25142
25143 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25144 {
25145         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25146         ndr->depth++;
25147         if (flags & NDR_SET_VALUES) {
25148                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25149         }
25150         if (flags & NDR_IN) {
25151                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25152                 ndr->depth++;
25153                 ndr->depth--;
25154         }
25155         if (flags & NDR_OUT) {
25156                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25157                 ndr->depth++;
25158                 ndr_print_WERROR(ndr, "result", r->out.result);
25159                 ndr->depth--;
25160         }
25161         ndr->depth--;
25162 }
25163
25164 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25165 {
25166         if (flags & NDR_IN) {
25167         }
25168         if (flags & NDR_OUT) {
25169                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25170         }
25171         return NDR_ERR_SUCCESS;
25172 }
25173
25174 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25175 {
25176         if (flags & NDR_IN) {
25177         }
25178         if (flags & NDR_OUT) {
25179                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25180         }
25181         return NDR_ERR_SUCCESS;
25182 }
25183
25184 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25185 {
25186         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25187         ndr->depth++;
25188         if (flags & NDR_SET_VALUES) {
25189                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25190         }
25191         if (flags & NDR_IN) {
25192                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25193                 ndr->depth++;
25194                 ndr->depth--;
25195         }
25196         if (flags & NDR_OUT) {
25197                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25198                 ndr->depth++;
25199                 ndr_print_WERROR(ndr, "result", r->out.result);
25200                 ndr->depth--;
25201         }
25202         ndr->depth--;
25203 }
25204
25205 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25206 {
25207         if (flags & NDR_IN) {
25208         }
25209         if (flags & NDR_OUT) {
25210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25211         }
25212         return NDR_ERR_SUCCESS;
25213 }
25214
25215 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25216 {
25217         if (flags & NDR_IN) {
25218         }
25219         if (flags & NDR_OUT) {
25220                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25221         }
25222         return NDR_ERR_SUCCESS;
25223 }
25224
25225 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25226 {
25227         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25228         ndr->depth++;
25229         if (flags & NDR_SET_VALUES) {
25230                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25231         }
25232         if (flags & NDR_IN) {
25233                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25234                 ndr->depth++;
25235                 ndr->depth--;
25236         }
25237         if (flags & NDR_OUT) {
25238                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25239                 ndr->depth++;
25240                 ndr_print_WERROR(ndr, "result", r->out.result);
25241                 ndr->depth--;
25242         }
25243         ndr->depth--;
25244 }
25245
25246 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25247 {
25248         if (flags & NDR_IN) {
25249         }
25250         if (flags & NDR_OUT) {
25251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25252         }
25253         return NDR_ERR_SUCCESS;
25254 }
25255
25256 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25257 {
25258         if (flags & NDR_IN) {
25259         }
25260         if (flags & NDR_OUT) {
25261                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25262         }
25263         return NDR_ERR_SUCCESS;
25264 }
25265
25266 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25267 {
25268         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25269         ndr->depth++;
25270         if (flags & NDR_SET_VALUES) {
25271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25272         }
25273         if (flags & NDR_IN) {
25274                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25275                 ndr->depth++;
25276                 ndr->depth--;
25277         }
25278         if (flags & NDR_OUT) {
25279                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25280                 ndr->depth++;
25281                 ndr_print_WERROR(ndr, "result", r->out.result);
25282                 ndr->depth--;
25283         }
25284         ndr->depth--;
25285 }
25286
25287 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25288 {
25289         if (flags & NDR_IN) {
25290         }
25291         if (flags & NDR_OUT) {
25292                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25293         }
25294         return NDR_ERR_SUCCESS;
25295 }
25296
25297 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25298 {
25299         if (flags & NDR_IN) {
25300         }
25301         if (flags & NDR_OUT) {
25302                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25303         }
25304         return NDR_ERR_SUCCESS;
25305 }
25306
25307 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25308 {
25309         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25310         ndr->depth++;
25311         if (flags & NDR_SET_VALUES) {
25312                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25313         }
25314         if (flags & NDR_IN) {
25315                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25316                 ndr->depth++;
25317                 ndr->depth--;
25318         }
25319         if (flags & NDR_OUT) {
25320                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25321                 ndr->depth++;
25322                 ndr_print_WERROR(ndr, "result", r->out.result);
25323                 ndr->depth--;
25324         }
25325         ndr->depth--;
25326 }
25327
25328 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25329 {
25330         if (flags & NDR_IN) {
25331         }
25332         if (flags & NDR_OUT) {
25333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25334         }
25335         return NDR_ERR_SUCCESS;
25336 }
25337
25338 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25339 {
25340         if (flags & NDR_IN) {
25341         }
25342         if (flags & NDR_OUT) {
25343                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25344         }
25345         return NDR_ERR_SUCCESS;
25346 }
25347
25348 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25349 {
25350         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25351         ndr->depth++;
25352         if (flags & NDR_SET_VALUES) {
25353                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25354         }
25355         if (flags & NDR_IN) {
25356                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25357                 ndr->depth++;
25358                 ndr->depth--;
25359         }
25360         if (flags & NDR_OUT) {
25361                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25362                 ndr->depth++;
25363                 ndr_print_WERROR(ndr, "result", r->out.result);
25364                 ndr->depth--;
25365         }
25366         ndr->depth--;
25367 }
25368
25369 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25370 {
25371         if (flags & NDR_IN) {
25372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25373                 if (r->in.servername) {
25374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25378                 }
25379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25380                 if (r->in.print_processor_name) {
25381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25383                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25384                         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));
25385                 }
25386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25388                 if (r->in.buffer) {
25389                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25390                 }
25391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25392         }
25393         if (flags & NDR_OUT) {
25394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25395                 if (r->out.info) {
25396                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25397                 }
25398                 if (r->out.needed == NULL) {
25399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25400                 }
25401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25402                 if (r->out.count == NULL) {
25403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25404                 }
25405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25407         }
25408         return NDR_ERR_SUCCESS;
25409 }
25410
25411 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25412 {
25413         uint32_t _ptr_servername;
25414         uint32_t _ptr_print_processor_name;
25415         uint32_t _ptr_buffer;
25416         uint32_t _ptr_info;
25417         TALLOC_CTX *_mem_save_servername_0;
25418         TALLOC_CTX *_mem_save_print_processor_name_0;
25419         TALLOC_CTX *_mem_save_buffer_0;
25420         TALLOC_CTX *_mem_save_info_0;
25421         TALLOC_CTX *_mem_save_needed_0;
25422         TALLOC_CTX *_mem_save_count_0;
25423         if (flags & NDR_IN) {
25424                 ZERO_STRUCT(r->out);
25425
25426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25427                 if (_ptr_servername) {
25428                         NDR_PULL_ALLOC(ndr, r->in.servername);
25429                 } else {
25430                         r->in.servername = NULL;
25431                 }
25432                 if (r->in.servername) {
25433                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25434                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25437                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25438                                 return 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));
25439                         }
25440                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25441                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25443                 }
25444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25445                 if (_ptr_print_processor_name) {
25446                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25447                 } else {
25448                         r->in.print_processor_name = NULL;
25449                 }
25450                 if (r->in.print_processor_name) {
25451                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25452                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25454                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25455                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25456                                 return 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));
25457                         }
25458                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25459                         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));
25460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25461                 }
25462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25464                 if (_ptr_buffer) {
25465                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25466                 } else {
25467                         r->in.buffer = NULL;
25468                 }
25469                 if (r->in.buffer) {
25470                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25471                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25472                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25474                 }
25475                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25476                 NDR_PULL_ALLOC(ndr, r->out.needed);
25477                 ZERO_STRUCTP(r->out.needed);
25478                 NDR_PULL_ALLOC(ndr, r->out.count);
25479                 ZERO_STRUCTP(r->out.count);
25480         }
25481         if (flags & NDR_OUT) {
25482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25483                 if (_ptr_info) {
25484                         NDR_PULL_ALLOC(ndr, r->out.info);
25485                 } else {
25486                         r->out.info = NULL;
25487                 }
25488                 if (r->out.info) {
25489                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25490                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25491                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25493                 }
25494                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25495                         NDR_PULL_ALLOC(ndr, r->out.needed);
25496                 }
25497                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25498                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25501                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25502                         NDR_PULL_ALLOC(ndr, r->out.count);
25503                 }
25504                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25505                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25508                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25509         }
25510         return NDR_ERR_SUCCESS;
25511 }
25512
25513 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25514 {
25515         uint32_t cntr_info_0;
25516         if (flags & NDR_IN) {
25517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25519         }
25520         if (flags & NDR_OUT) {
25521                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25522                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25523                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25524                 }
25525                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25526                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25527                 }
25528         }
25529         return NDR_ERR_SUCCESS;
25530 }
25531
25532 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25533 {
25534         uint32_t cntr_info_0;
25535         TALLOC_CTX *_mem_save_info_0;
25536         if (flags & NDR_IN) {
25537                 ZERO_STRUCT(r->out);
25538
25539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25541         }
25542         if (flags & NDR_OUT) {
25543                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25544                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25545                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25546                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25547                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25548                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25549                 }
25550                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25551                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25552                 }
25553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25554         }
25555         return NDR_ERR_SUCCESS;
25556 }
25557
25558 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
25559 {
25560         uint32_t cntr_info_2;
25561         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
25562         ndr->depth++;
25563         if (flags & NDR_SET_VALUES) {
25564                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25565         }
25566         if (flags & NDR_IN) {
25567                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
25568                 ndr->depth++;
25569                 ndr_print_ptr(ndr, "servername", r->in.servername);
25570                 ndr->depth++;
25571                 if (r->in.servername) {
25572                         ndr_print_string(ndr, "servername", r->in.servername);
25573                 }
25574                 ndr->depth--;
25575                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25576                 ndr->depth++;
25577                 if (r->in.print_processor_name) {
25578                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25579                 }
25580                 ndr->depth--;
25581                 ndr_print_uint32(ndr, "level", r->in.level);
25582                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25583                 ndr->depth++;
25584                 if (r->in.buffer) {
25585                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25586                 }
25587                 ndr->depth--;
25588                 ndr_print_uint32(ndr, "offered", r->in.offered);
25589                 ndr->depth--;
25590         }
25591         if (flags & NDR_OUT) {
25592                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25593                 ndr->depth++;
25594                 ndr_print_ptr(ndr, "count", r->out.count);
25595                 ndr->depth++;
25596                 ndr_print_uint32(ndr, "count", *r->out.count);
25597                 ndr->depth--;
25598                 ndr_print_ptr(ndr, "info", r->out.info);
25599                 ndr->depth++;
25600                 ndr_print_ptr(ndr, "info", *r->out.info);
25601                 ndr->depth++;
25602                 if (*r->out.info) {
25603                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25604                         ndr->depth++;
25605                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25606                                 char *idx_2=NULL;
25607                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25608                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25609                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25610                                         free(idx_2);
25611                                 }
25612                         }
25613                         ndr->depth--;
25614                 }
25615                 ndr->depth--;
25616                 ndr->depth--;
25617                 ndr_print_ptr(ndr, "needed", r->out.needed);
25618                 ndr->depth++;
25619                 ndr_print_uint32(ndr, "needed", *r->out.needed);
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_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25628 {
25629         if (flags & NDR_IN) {
25630                 if (r->in.handle == NULL) {
25631                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25632                 }
25633                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25635                 if (r->in.data_type) {
25636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25637                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25638                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25639                         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));
25640                 }
25641                 if (r->in.devmode_ctr == NULL) {
25642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25643                 }
25644                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25645         }
25646         if (flags & NDR_OUT) {
25647                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25648         }
25649         return NDR_ERR_SUCCESS;
25650 }
25651
25652 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25653 {
25654         uint32_t _ptr_data_type;
25655         TALLOC_CTX *_mem_save_handle_0;
25656         TALLOC_CTX *_mem_save_data_type_0;
25657         TALLOC_CTX *_mem_save_devmode_ctr_0;
25658         if (flags & NDR_IN) {
25659                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25660                         NDR_PULL_ALLOC(ndr, r->in.handle);
25661                 }
25662                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25663                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25664                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25665                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25667                 if (_ptr_data_type) {
25668                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25669                 } else {
25670                         r->in.data_type = NULL;
25671                 }
25672                 if (r->in.data_type) {
25673                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25674                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25676                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25677                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25678                                 return 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));
25679                         }
25680                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
25681                         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));
25682                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
25683                 }
25684                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25685                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25686                 }
25687                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25688                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25689                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25690                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25691         }
25692         if (flags & NDR_OUT) {
25693                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25694         }
25695         return NDR_ERR_SUCCESS;
25696 }
25697
25698 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
25699 {
25700         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
25701         ndr->depth++;
25702         if (flags & NDR_SET_VALUES) {
25703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25704         }
25705         if (flags & NDR_IN) {
25706                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
25707                 ndr->depth++;
25708                 ndr_print_ptr(ndr, "handle", r->in.handle);
25709                 ndr->depth++;
25710                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25711                 ndr->depth--;
25712                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
25713                 ndr->depth++;
25714                 if (r->in.data_type) {
25715                         ndr_print_string(ndr, "data_type", r->in.data_type);
25716                 }
25717                 ndr->depth--;
25718                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25719                 ndr->depth++;
25720                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25721                 ndr->depth--;
25722                 ndr->depth--;
25723         }
25724         if (flags & NDR_OUT) {
25725                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
25726                 ndr->depth++;
25727                 ndr_print_WERROR(ndr, "result", r->out.result);
25728                 ndr->depth--;
25729         }
25730         ndr->depth--;
25731 }
25732
25733 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
25734 {
25735         if (flags & NDR_IN) {
25736                 if (r->in.handle == NULL) {
25737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25738                 }
25739                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
25741                 if (r->in.architecture) {
25742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25743                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25744                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25745                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25746                 }
25747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25749                 if (r->in.buffer) {
25750                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25751                 }
25752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
25754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
25755         }
25756         if (flags & NDR_OUT) {
25757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25758                 if (r->out.info) {
25759                         {
25760                                 struct ndr_push *_ndr_info;
25761                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25762                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
25763                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25764                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25765                         }
25766                 }
25767                 if (r->out.needed == NULL) {
25768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25769                 }
25770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25771                 if (r->out.server_major_version == NULL) {
25772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25773                 }
25774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
25775                 if (r->out.server_minor_version == NULL) {
25776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25777                 }
25778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
25779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25780         }
25781         return NDR_ERR_SUCCESS;
25782 }
25783
25784 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
25785 {
25786         uint32_t _ptr_architecture;
25787         uint32_t _ptr_buffer;
25788         uint32_t _ptr_info;
25789         TALLOC_CTX *_mem_save_handle_0;
25790         TALLOC_CTX *_mem_save_architecture_0;
25791         TALLOC_CTX *_mem_save_buffer_0;
25792         TALLOC_CTX *_mem_save_info_0;
25793         TALLOC_CTX *_mem_save_needed_0;
25794         TALLOC_CTX *_mem_save_server_major_version_0;
25795         TALLOC_CTX *_mem_save_server_minor_version_0;
25796         if (flags & NDR_IN) {
25797                 ZERO_STRUCT(r->out);
25798
25799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25800                         NDR_PULL_ALLOC(ndr, r->in.handle);
25801                 }
25802                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
25807                 if (_ptr_architecture) {
25808                         NDR_PULL_ALLOC(ndr, r->in.architecture);
25809                 } else {
25810                         r->in.architecture = NULL;
25811                 }
25812                 if (r->in.architecture) {
25813                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
25814                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
25815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
25816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
25817                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
25818                                 return 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));
25819                         }
25820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
25821                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
25822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
25823                 }
25824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25826                 if (_ptr_buffer) {
25827                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25828                 } else {
25829                         r->in.buffer = NULL;
25830                 }
25831                 if (r->in.buffer) {
25832                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25833                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25834                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25836                 }
25837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
25839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
25840                 NDR_PULL_ALLOC(ndr, r->out.needed);
25841                 ZERO_STRUCTP(r->out.needed);
25842                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25843                 ZERO_STRUCTP(r->out.server_major_version);
25844                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25845                 ZERO_STRUCTP(r->out.server_minor_version);
25846         }
25847         if (flags & NDR_OUT) {
25848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25849                 if (_ptr_info) {
25850                         NDR_PULL_ALLOC(ndr, r->out.info);
25851                 } else {
25852                         r->out.info = NULL;
25853                 }
25854                 if (r->out.info) {
25855                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25856                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25857                         {
25858                                 struct ndr_pull *_ndr_info;
25859                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25860                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
25861                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25862                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25863                         }
25864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25865                 }
25866                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25867                         NDR_PULL_ALLOC(ndr, r->out.needed);
25868                 }
25869                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25870                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25872                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25873                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25874                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25875                 }
25876                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25877                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25880                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25881                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25882                 }
25883                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25884                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
25885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
25886                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
25887                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25888         }
25889         return NDR_ERR_SUCCESS;
25890 }
25891
25892 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
25893 {
25894         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
25895         ndr->depth++;
25896         if (flags & NDR_SET_VALUES) {
25897                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25898         }
25899         if (flags & NDR_IN) {
25900                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
25901                 ndr->depth++;
25902                 ndr_print_ptr(ndr, "handle", r->in.handle);
25903                 ndr->depth++;
25904                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25905                 ndr->depth--;
25906                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
25907                 ndr->depth++;
25908                 if (r->in.architecture) {
25909                         ndr_print_string(ndr, "architecture", r->in.architecture);
25910                 }
25911                 ndr->depth--;
25912                 ndr_print_uint32(ndr, "level", r->in.level);
25913                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25914                 ndr->depth++;
25915                 if (r->in.buffer) {
25916                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25917                 }
25918                 ndr->depth--;
25919                 ndr_print_uint32(ndr, "offered", r->in.offered);
25920                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
25921                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
25922                 ndr->depth--;
25923         }
25924         if (flags & NDR_OUT) {
25925                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
25926                 ndr->depth++;
25927                 ndr_print_ptr(ndr, "info", r->out.info);
25928                 ndr->depth++;
25929                 if (r->out.info) {
25930                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
25931                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
25932                 }
25933                 ndr->depth--;
25934                 ndr_print_ptr(ndr, "needed", r->out.needed);
25935                 ndr->depth++;
25936                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25937                 ndr->depth--;
25938                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
25939                 ndr->depth++;
25940                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
25941                 ndr->depth--;
25942                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
25943                 ndr->depth++;
25944                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
25945                 ndr->depth--;
25946                 ndr_print_WERROR(ndr, "result", r->out.result);
25947                 ndr->depth--;
25948         }
25949         ndr->depth--;
25950 }
25951
25952 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25953 {
25954         if (flags & NDR_IN) {
25955         }
25956         if (flags & NDR_OUT) {
25957                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25958         }
25959         return NDR_ERR_SUCCESS;
25960 }
25961
25962 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
25963 {
25964         if (flags & NDR_IN) {
25965         }
25966         if (flags & NDR_OUT) {
25967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25968         }
25969         return NDR_ERR_SUCCESS;
25970 }
25971
25972 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25973 {
25974         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
25975         ndr->depth++;
25976         if (flags & NDR_SET_VALUES) {
25977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25978         }
25979         if (flags & NDR_IN) {
25980                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
25981                 ndr->depth++;
25982                 ndr->depth--;
25983         }
25984         if (flags & NDR_OUT) {
25985                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
25986                 ndr->depth++;
25987                 ndr_print_WERROR(ndr, "result", r->out.result);
25988                 ndr->depth--;
25989         }
25990         ndr->depth--;
25991 }
25992
25993 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25994 {
25995         if (flags & NDR_IN) {
25996         }
25997         if (flags & NDR_OUT) {
25998                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25999         }
26000         return NDR_ERR_SUCCESS;
26001 }
26002
26003 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26004 {
26005         if (flags & NDR_IN) {
26006         }
26007         if (flags & NDR_OUT) {
26008                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26009         }
26010         return NDR_ERR_SUCCESS;
26011 }
26012
26013 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26014 {
26015         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26016         ndr->depth++;
26017         if (flags & NDR_SET_VALUES) {
26018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26019         }
26020         if (flags & NDR_IN) {
26021                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26022                 ndr->depth++;
26023                 ndr->depth--;
26024         }
26025         if (flags & NDR_OUT) {
26026                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26027                 ndr->depth++;
26028                 ndr_print_WERROR(ndr, "result", r->out.result);
26029                 ndr->depth--;
26030         }
26031         ndr->depth--;
26032 }
26033
26034 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26035 {
26036         if (flags & NDR_IN) {
26037                 if (r->in.handle == NULL) {
26038                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26039                 }
26040                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26041         }
26042         if (flags & NDR_OUT) {
26043                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26044         }
26045         return NDR_ERR_SUCCESS;
26046 }
26047
26048 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26049 {
26050         TALLOC_CTX *_mem_save_handle_0;
26051         if (flags & NDR_IN) {
26052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26053                         NDR_PULL_ALLOC(ndr, r->in.handle);
26054                 }
26055                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26056                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26057                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26059         }
26060         if (flags & NDR_OUT) {
26061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26062         }
26063         return NDR_ERR_SUCCESS;
26064 }
26065
26066 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26067 {
26068         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26069         ndr->depth++;
26070         if (flags & NDR_SET_VALUES) {
26071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26072         }
26073         if (flags & NDR_IN) {
26074                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26075                 ndr->depth++;
26076                 ndr_print_ptr(ndr, "handle", r->in.handle);
26077                 ndr->depth++;
26078                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26079                 ndr->depth--;
26080                 ndr->depth--;
26081         }
26082         if (flags & NDR_OUT) {
26083                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26084                 ndr->depth++;
26085                 ndr_print_WERROR(ndr, "result", r->out.result);
26086                 ndr->depth--;
26087         }
26088         ndr->depth--;
26089 }
26090
26091 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26092 {
26093         if (flags & NDR_IN) {
26094         }
26095         if (flags & NDR_OUT) {
26096                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26097         }
26098         return NDR_ERR_SUCCESS;
26099 }
26100
26101 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26102 {
26103         if (flags & NDR_IN) {
26104         }
26105         if (flags & NDR_OUT) {
26106                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26107         }
26108         return NDR_ERR_SUCCESS;
26109 }
26110
26111 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26112 {
26113         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26114         ndr->depth++;
26115         if (flags & NDR_SET_VALUES) {
26116                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26117         }
26118         if (flags & NDR_IN) {
26119                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26120                 ndr->depth++;
26121                 ndr->depth--;
26122         }
26123         if (flags & NDR_OUT) {
26124                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26125                 ndr->depth++;
26126                 ndr_print_WERROR(ndr, "result", r->out.result);
26127                 ndr->depth--;
26128         }
26129         ndr->depth--;
26130 }
26131
26132 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26133 {
26134         if (flags & NDR_IN) {
26135                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26136                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26137                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26138                 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));
26139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26140                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26142                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26143                 if (r->in.buffer) {
26144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26145                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26146                 }
26147         }
26148         if (flags & NDR_OUT) {
26149                 if (r->out.handle == NULL) {
26150                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26151                 }
26152                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26154         }
26155         return NDR_ERR_SUCCESS;
26156 }
26157
26158 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26159 {
26160         uint32_t _ptr_buffer;
26161         TALLOC_CTX *_mem_save_buffer_0;
26162         TALLOC_CTX *_mem_save_handle_0;
26163         if (flags & NDR_IN) {
26164                 ZERO_STRUCT(r->out);
26165
26166                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26167                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26168                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26169                         return 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));
26170                 }
26171                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26172                 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));
26173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26174                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26176                 if (r->in.bufsize > 512) {
26177                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26178                 }
26179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26180                 if (_ptr_buffer) {
26181                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26182                 } else {
26183                         r->in.buffer = NULL;
26184                 }
26185                 if (r->in.buffer) {
26186                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26187                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26188                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26189                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26190                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26192                 }
26193                 NDR_PULL_ALLOC(ndr, r->out.handle);
26194                 ZERO_STRUCTP(r->out.handle);
26195                 if (r->in.buffer) {
26196                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26197                 }
26198         }
26199         if (flags & NDR_OUT) {
26200                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26201                         NDR_PULL_ALLOC(ndr, r->out.handle);
26202                 }
26203                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26204                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26205                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26207                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26208         }
26209         return NDR_ERR_SUCCESS;
26210 }
26211
26212 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26213 {
26214         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26215         ndr->depth++;
26216         if (flags & NDR_SET_VALUES) {
26217                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26218         }
26219         if (flags & NDR_IN) {
26220                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26221                 ndr->depth++;
26222                 ndr_print_string(ndr, "server_name", r->in.server_name);
26223                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26224                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26225                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26226                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26227                 ndr->depth++;
26228                 if (r->in.buffer) {
26229                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26230                 }
26231                 ndr->depth--;
26232                 ndr->depth--;
26233         }
26234         if (flags & NDR_OUT) {
26235                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26236                 ndr->depth++;
26237                 ndr_print_ptr(ndr, "handle", r->out.handle);
26238                 ndr->depth++;
26239                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26240                 ndr->depth--;
26241                 ndr_print_WERROR(ndr, "result", r->out.result);
26242                 ndr->depth--;
26243         }
26244         ndr->depth--;
26245 }
26246
26247 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26248 {
26249         if (flags & NDR_IN) {
26250                 if (r->in.handle == NULL) {
26251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26252                 }
26253                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26254                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26257                 if (r->in.buffer) {
26258                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26259                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26260                 }
26261         }
26262         if (flags & NDR_OUT) {
26263                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26264         }
26265         return NDR_ERR_SUCCESS;
26266 }
26267
26268 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26269 {
26270         uint32_t _ptr_buffer;
26271         TALLOC_CTX *_mem_save_handle_0;
26272         TALLOC_CTX *_mem_save_buffer_0;
26273         if (flags & NDR_IN) {
26274                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26275                         NDR_PULL_ALLOC(ndr, r->in.handle);
26276                 }
26277                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26278                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26279                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26280                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26281                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26283                 if (r->in.bufsize > 512) {
26284                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26285                 }
26286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26287                 if (_ptr_buffer) {
26288                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26289                 } else {
26290                         r->in.buffer = NULL;
26291                 }
26292                 if (r->in.buffer) {
26293                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26296                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26297                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26299                 }
26300                 if (r->in.buffer) {
26301                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26302                 }
26303         }
26304         if (flags & NDR_OUT) {
26305                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26306         }
26307         return NDR_ERR_SUCCESS;
26308 }
26309
26310 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26311 {
26312         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26313         ndr->depth++;
26314         if (flags & NDR_SET_VALUES) {
26315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26316         }
26317         if (flags & NDR_IN) {
26318                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26319                 ndr->depth++;
26320                 ndr_print_ptr(ndr, "handle", r->in.handle);
26321                 ndr->depth++;
26322                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26323                 ndr->depth--;
26324                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26325                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26326                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26327                 ndr->depth++;
26328                 if (r->in.buffer) {
26329                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26330                 }
26331                 ndr->depth--;
26332                 ndr->depth--;
26333         }
26334         if (flags & NDR_OUT) {
26335                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26336                 ndr->depth++;
26337                 ndr_print_WERROR(ndr, "result", r->out.result);
26338                 ndr->depth--;
26339         }
26340         ndr->depth--;
26341 }
26342
26343 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26344 {
26345         if (flags & NDR_IN) {
26346                 if (r->in.handle == NULL) {
26347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26348                 }
26349                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26350         }
26351         if (flags & NDR_OUT) {
26352                 if (r->out.handle == NULL) {
26353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26354                 }
26355                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26356                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26357         }
26358         return NDR_ERR_SUCCESS;
26359 }
26360
26361 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26362 {
26363         TALLOC_CTX *_mem_save_handle_0;
26364         if (flags & NDR_IN) {
26365                 ZERO_STRUCT(r->out);
26366
26367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26368                         NDR_PULL_ALLOC(ndr, r->in.handle);
26369                 }
26370                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26371                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26372                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26374                 NDR_PULL_ALLOC(ndr, r->out.handle);
26375                 *r->out.handle = *r->in.handle;
26376         }
26377         if (flags & NDR_OUT) {
26378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26379                         NDR_PULL_ALLOC(ndr, r->out.handle);
26380                 }
26381                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26382                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26383                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26385                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26386         }
26387         return NDR_ERR_SUCCESS;
26388 }
26389
26390 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26391 {
26392         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26393         ndr->depth++;
26394         if (flags & NDR_SET_VALUES) {
26395                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26396         }
26397         if (flags & NDR_IN) {
26398                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26399                 ndr->depth++;
26400                 ndr_print_ptr(ndr, "handle", r->in.handle);
26401                 ndr->depth++;
26402                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26403                 ndr->depth--;
26404                 ndr->depth--;
26405         }
26406         if (flags & NDR_OUT) {
26407                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26408                 ndr->depth++;
26409                 ndr_print_ptr(ndr, "handle", r->out.handle);
26410                 ndr->depth++;
26411                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26412                 ndr->depth--;
26413                 ndr_print_WERROR(ndr, "result", r->out.result);
26414                 ndr->depth--;
26415         }
26416         ndr->depth--;
26417 }
26418
26419 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26420 {
26421         if (flags & NDR_IN) {
26422         }
26423         if (flags & NDR_OUT) {
26424                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26425         }
26426         return NDR_ERR_SUCCESS;
26427 }
26428
26429 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26430 {
26431         if (flags & NDR_IN) {
26432         }
26433         if (flags & NDR_OUT) {
26434                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26435         }
26436         return NDR_ERR_SUCCESS;
26437 }
26438
26439 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26440 {
26441         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
26442         ndr->depth++;
26443         if (flags & NDR_SET_VALUES) {
26444                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26445         }
26446         if (flags & NDR_IN) {
26447                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
26448                 ndr->depth++;
26449                 ndr->depth--;
26450         }
26451         if (flags & NDR_OUT) {
26452                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26453                 ndr->depth++;
26454                 ndr_print_WERROR(ndr, "result", r->out.result);
26455                 ndr->depth--;
26456         }
26457         ndr->depth--;
26458 }
26459
26460 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26461 {
26462         if (flags & NDR_IN) {
26463         }
26464         if (flags & NDR_OUT) {
26465                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26466         }
26467         return NDR_ERR_SUCCESS;
26468 }
26469
26470 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26471 {
26472         if (flags & NDR_IN) {
26473         }
26474         if (flags & NDR_OUT) {
26475                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26476         }
26477         return NDR_ERR_SUCCESS;
26478 }
26479
26480 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26481 {
26482         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26483         ndr->depth++;
26484         if (flags & NDR_SET_VALUES) {
26485                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26486         }
26487         if (flags & NDR_IN) {
26488                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26489                 ndr->depth++;
26490                 ndr->depth--;
26491         }
26492         if (flags & NDR_OUT) {
26493                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26494                 ndr->depth++;
26495                 ndr_print_WERROR(ndr, "result", r->out.result);
26496                 ndr->depth--;
26497         }
26498         ndr->depth--;
26499 }
26500
26501 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26502 {
26503         if (flags & NDR_IN) {
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 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26512 {
26513         if (flags & NDR_IN) {
26514         }
26515         if (flags & NDR_OUT) {
26516                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26517         }
26518         return NDR_ERR_SUCCESS;
26519 }
26520
26521 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26522 {
26523         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26524         ndr->depth++;
26525         if (flags & NDR_SET_VALUES) {
26526                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26527         }
26528         if (flags & NDR_IN) {
26529                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26530                 ndr->depth++;
26531                 ndr->depth--;
26532         }
26533         if (flags & NDR_OUT) {
26534                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26535                 ndr->depth++;
26536                 ndr_print_WERROR(ndr, "result", r->out.result);
26537                 ndr->depth--;
26538         }
26539         ndr->depth--;
26540 }
26541
26542 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
26543 {
26544         if (flags & NDR_IN) {
26545         }
26546         if (flags & NDR_OUT) {
26547                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26548         }
26549         return NDR_ERR_SUCCESS;
26550 }
26551
26552 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
26553 {
26554         if (flags & NDR_IN) {
26555         }
26556         if (flags & NDR_OUT) {
26557                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26558         }
26559         return NDR_ERR_SUCCESS;
26560 }
26561
26562 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
26563 {
26564         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
26565         ndr->depth++;
26566         if (flags & NDR_SET_VALUES) {
26567                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26568         }
26569         if (flags & NDR_IN) {
26570                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
26571                 ndr->depth++;
26572                 ndr->depth--;
26573         }
26574         if (flags & NDR_OUT) {
26575                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26576                 ndr->depth++;
26577                 ndr_print_WERROR(ndr, "result", r->out.result);
26578                 ndr->depth--;
26579         }
26580         ndr->depth--;
26581 }
26582
26583 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26584 {
26585         if (flags & NDR_IN) {
26586                 if (r->in.handle == NULL) {
26587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26588                 }
26589                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26590                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26592                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26593                 if (r->in.local_machine) {
26594                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26595                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26597                         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));
26598                 }
26599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26601                 if (r->in.notify_options) {
26602                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26603                 }
26604         }
26605         if (flags & NDR_OUT) {
26606                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26607         }
26608         return NDR_ERR_SUCCESS;
26609 }
26610
26611 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26612 {
26613         uint32_t _ptr_local_machine;
26614         uint32_t _ptr_notify_options;
26615         TALLOC_CTX *_mem_save_handle_0;
26616         TALLOC_CTX *_mem_save_local_machine_0;
26617         TALLOC_CTX *_mem_save_notify_options_0;
26618         if (flags & NDR_IN) {
26619                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26620                         NDR_PULL_ALLOC(ndr, r->in.handle);
26621                 }
26622                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26623                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26624                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26625                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26626                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26629                 if (_ptr_local_machine) {
26630                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
26631                 } else {
26632                         r->in.local_machine = NULL;
26633                 }
26634                 if (r->in.local_machine) {
26635                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26636                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26638                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26639                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26640                                 return 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));
26641                         }
26642                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26643                         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));
26644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26645                 }
26646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26647                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26648                 if (_ptr_notify_options) {
26649                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
26650                 } else {
26651                         r->in.notify_options = NULL;
26652                 }
26653                 if (r->in.notify_options) {
26654                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26655                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26656                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26658                 }
26659         }
26660         if (flags & NDR_OUT) {
26661                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26662         }
26663         return NDR_ERR_SUCCESS;
26664 }
26665
26666 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26667 {
26668         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26669         ndr->depth++;
26670         if (flags & NDR_SET_VALUES) {
26671                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26672         }
26673         if (flags & NDR_IN) {
26674                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26675                 ndr->depth++;
26676                 ndr_print_ptr(ndr, "handle", r->in.handle);
26677                 ndr->depth++;
26678                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26679                 ndr->depth--;
26680                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26681                 ndr_print_uint32(ndr, "options", r->in.options);
26682                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
26683                 ndr->depth++;
26684                 if (r->in.local_machine) {
26685                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
26686                 }
26687                 ndr->depth--;
26688                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26689                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
26690                 ndr->depth++;
26691                 if (r->in.notify_options) {
26692                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
26693                 }
26694                 ndr->depth--;
26695                 ndr->depth--;
26696         }
26697         if (flags & NDR_OUT) {
26698                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26699                 ndr->depth++;
26700                 ndr_print_WERROR(ndr, "result", r->out.result);
26701                 ndr->depth--;
26702         }
26703         ndr->depth--;
26704 }
26705
26706 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26707 {
26708         if (flags & NDR_IN) {
26709                 if (r->in.handle == NULL) {
26710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26711                 }
26712                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
26714                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
26716                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26717                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26718         }
26719         if (flags & NDR_OUT) {
26720                 if (r->out.reply_result == NULL) {
26721                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26722                 }
26723                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
26724                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26725         }
26726         return NDR_ERR_SUCCESS;
26727 }
26728
26729 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
26730 {
26731         TALLOC_CTX *_mem_save_handle_0;
26732         TALLOC_CTX *_mem_save_reply_result_0;
26733         if (flags & NDR_IN) {
26734                 ZERO_STRUCT(r->out);
26735
26736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26737                         NDR_PULL_ALLOC(ndr, r->in.handle);
26738                 }
26739                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26741                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
26744                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
26746                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26747                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26748                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
26749                 ZERO_STRUCTP(r->out.reply_result);
26750         }
26751         if (flags & NDR_OUT) {
26752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26753                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
26754                 }
26755                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
26756                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
26757                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
26758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
26759                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26760         }
26761         return NDR_ERR_SUCCESS;
26762 }
26763
26764 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26765 {
26766         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
26767         ndr->depth++;
26768         if (flags & NDR_SET_VALUES) {
26769                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26770         }
26771         if (flags & NDR_IN) {
26772                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
26773                 ndr->depth++;
26774                 ndr_print_ptr(ndr, "handle", r->in.handle);
26775                 ndr->depth++;
26776                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26777                 ndr->depth--;
26778                 ndr_print_uint32(ndr, "color", r->in.color);
26779                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26780                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
26781                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
26782                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
26783                 ndr->depth--;
26784         }
26785         if (flags & NDR_OUT) {
26786                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
26787                 ndr->depth++;
26788                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
26789                 ndr->depth++;
26790                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
26791                 ndr->depth--;
26792                 ndr_print_WERROR(ndr, "result", r->out.result);
26793                 ndr->depth--;
26794         }
26795         ndr->depth--;
26796 }
26797
26798 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26799 {
26800         if (flags & NDR_IN) {
26801                 if (r->in.handle == NULL) {
26802                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26803                 }
26804                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
26806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
26807                 if (r->in.options) {
26808                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26809                 }
26810         }
26811         if (flags & NDR_OUT) {
26812                 if (r->out.info == NULL) {
26813                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26814                 }
26815                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
26816                 if (*r->out.info) {
26817                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26818                 }
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_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
26825 {
26826         uint32_t _ptr_options;
26827         uint32_t _ptr_info;
26828         TALLOC_CTX *_mem_save_handle_0;
26829         TALLOC_CTX *_mem_save_options_0;
26830         TALLOC_CTX *_mem_save_info_0;
26831         TALLOC_CTX *_mem_save_info_1;
26832         if (flags & NDR_IN) {
26833                 ZERO_STRUCT(r->out);
26834
26835                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26836                         NDR_PULL_ALLOC(ndr, r->in.handle);
26837                 }
26838                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26839                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26840                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
26843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
26844                 if (_ptr_options) {
26845                         NDR_PULL_ALLOC(ndr, r->in.options);
26846                 } else {
26847                         r->in.options = NULL;
26848                 }
26849                 if (r->in.options) {
26850                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26851                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
26852                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26853                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
26854                 }
26855                 NDR_PULL_ALLOC(ndr, r->out.info);
26856                 ZERO_STRUCTP(r->out.info);
26857         }
26858         if (flags & NDR_OUT) {
26859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26860                         NDR_PULL_ALLOC(ndr, r->out.info);
26861                 }
26862                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26863                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26865                 if (_ptr_info) {
26866                         NDR_PULL_ALLOC(ndr, *r->out.info);
26867                 } else {
26868                         *r->out.info = NULL;
26869                 }
26870                 if (*r->out.info) {
26871                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26872                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26873                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26875                 }
26876                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26877                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26878         }
26879         return NDR_ERR_SUCCESS;
26880 }
26881
26882 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26883 {
26884         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
26885         ndr->depth++;
26886         if (flags & NDR_SET_VALUES) {
26887                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26888         }
26889         if (flags & NDR_IN) {
26890                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
26891                 ndr->depth++;
26892                 ndr_print_ptr(ndr, "handle", r->in.handle);
26893                 ndr->depth++;
26894                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26895                 ndr->depth--;
26896                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
26897                 ndr_print_ptr(ndr, "options", r->in.options);
26898                 ndr->depth++;
26899                 if (r->in.options) {
26900                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
26901                 }
26902                 ndr->depth--;
26903                 ndr->depth--;
26904         }
26905         if (flags & NDR_OUT) {
26906                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
26907                 ndr->depth++;
26908                 ndr_print_ptr(ndr, "info", r->out.info);
26909                 ndr->depth++;
26910                 ndr_print_ptr(ndr, "info", *r->out.info);
26911                 ndr->depth++;
26912                 if (*r->out.info) {
26913                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
26914                 }
26915                 ndr->depth--;
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_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *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_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *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_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
26944 {
26945         ndr_print_struct(ndr, name, "spoolss_44");
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_44");
26952                 ndr->depth++;
26953                 ndr->depth--;
26954         }
26955         if (flags & NDR_OUT) {
26956                 ndr_print_struct(ndr, "out", "spoolss_44");
26957                 ndr->depth++;
26958                 ndr_print_WERROR(ndr, "result", r->out.result);
26959                 ndr->depth--;
26960         }
26961         ndr->depth--;
26962 }
26963
26964 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
26965 {
26966         if (flags & NDR_IN) {
26967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
26968                 if (r->in.printername) {
26969                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26973                 }
26974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
26975                 if (r->in.datatype) {
26976                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26979                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26980                 }
26981                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26982                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
26983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26984                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26985                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26986         }
26987         if (flags & NDR_OUT) {
26988                 if (r->out.handle == NULL) {
26989                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26990                 }
26991                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26992                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26993         }
26994         return NDR_ERR_SUCCESS;
26995 }
26996
26997 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
26998 {
26999         uint32_t _ptr_printername;
27000         uint32_t _ptr_datatype;
27001         TALLOC_CTX *_mem_save_printername_0;
27002         TALLOC_CTX *_mem_save_datatype_0;
27003         TALLOC_CTX *_mem_save_handle_0;
27004         if (flags & NDR_IN) {
27005                 ZERO_STRUCT(r->out);
27006
27007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27008                 if (_ptr_printername) {
27009                         NDR_PULL_ALLOC(ndr, r->in.printername);
27010                 } else {
27011                         r->in.printername = NULL;
27012                 }
27013                 if (r->in.printername) {
27014                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27015                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27018                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27019                                 return 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));
27020                         }
27021                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27022                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27024                 }
27025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27026                 if (_ptr_datatype) {
27027                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27028                 } else {
27029                         r->in.datatype = NULL;
27030                 }
27031                 if (r->in.datatype) {
27032                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27033                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27035                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27036                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27037                                 return 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));
27038                         }
27039                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27040                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27042                 }
27043                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27044                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27046                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27047                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27048                 NDR_PULL_ALLOC(ndr, r->out.handle);
27049                 ZERO_STRUCTP(r->out.handle);
27050         }
27051         if (flags & NDR_OUT) {
27052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27053                         NDR_PULL_ALLOC(ndr, r->out.handle);
27054                 }
27055                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27056                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27057                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27059                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27060         }
27061         return NDR_ERR_SUCCESS;
27062 }
27063
27064 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27065 {
27066         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27067         ndr->depth++;
27068         if (flags & NDR_SET_VALUES) {
27069                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27070         }
27071         if (flags & NDR_IN) {
27072                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27073                 ndr->depth++;
27074                 ndr_print_ptr(ndr, "printername", r->in.printername);
27075                 ndr->depth++;
27076                 if (r->in.printername) {
27077                         ndr_print_string(ndr, "printername", r->in.printername);
27078                 }
27079                 ndr->depth--;
27080                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27081                 ndr->depth++;
27082                 if (r->in.datatype) {
27083                         ndr_print_string(ndr, "datatype", r->in.datatype);
27084                 }
27085                 ndr->depth--;
27086                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27087                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27088                 ndr_print_uint32(ndr, "level", r->in.level);
27089                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27090                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27091                 ndr->depth--;
27092         }
27093         if (flags & NDR_OUT) {
27094                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27095                 ndr->depth++;
27096                 ndr_print_ptr(ndr, "handle", r->out.handle);
27097                 ndr->depth++;
27098                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27099                 ndr->depth--;
27100                 ndr_print_WERROR(ndr, "result", r->out.result);
27101                 ndr->depth--;
27102         }
27103         ndr->depth--;
27104 }
27105
27106 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27107 {
27108         if (flags & NDR_IN) {
27109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27110                 if (r->in.server) {
27111                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27115                 }
27116                 if (r->in.info_ctr == NULL) {
27117                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27118                 }
27119                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27120                 if (r->in.devmode_ctr == NULL) {
27121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27122                 }
27123                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27124                 if (r->in.secdesc_ctr == NULL) {
27125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27126                 }
27127                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27128                 if (r->in.userlevel_ctr == NULL) {
27129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27130                 }
27131                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27132         }
27133         if (flags & NDR_OUT) {
27134                 if (r->out.handle == NULL) {
27135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27136                 }
27137                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27138                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27139         }
27140         return NDR_ERR_SUCCESS;
27141 }
27142
27143 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27144 {
27145         uint32_t _ptr_server;
27146         TALLOC_CTX *_mem_save_server_0;
27147         TALLOC_CTX *_mem_save_info_ctr_0;
27148         TALLOC_CTX *_mem_save_devmode_ctr_0;
27149         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27150         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27151         TALLOC_CTX *_mem_save_handle_0;
27152         if (flags & NDR_IN) {
27153                 ZERO_STRUCT(r->out);
27154
27155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27156                 if (_ptr_server) {
27157                         NDR_PULL_ALLOC(ndr, r->in.server);
27158                 } else {
27159                         r->in.server = NULL;
27160                 }
27161                 if (r->in.server) {
27162                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27163                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27166                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27167                                 return 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));
27168                         }
27169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27172                 }
27173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27174                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27175                 }
27176                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27177                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27178                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27179                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27181                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27182                 }
27183                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27184                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27185                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27188                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27189                 }
27190                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27191                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27192                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27194                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27195                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27196                 }
27197                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27198                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27199                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27200                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27201                 NDR_PULL_ALLOC(ndr, r->out.handle);
27202                 ZERO_STRUCTP(r->out.handle);
27203         }
27204         if (flags & NDR_OUT) {
27205                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27206                         NDR_PULL_ALLOC(ndr, r->out.handle);
27207                 }
27208                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27209                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27210                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27211                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27212                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27213         }
27214         return NDR_ERR_SUCCESS;
27215 }
27216
27217 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27218 {
27219         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27220         ndr->depth++;
27221         if (flags & NDR_SET_VALUES) {
27222                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27223         }
27224         if (flags & NDR_IN) {
27225                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27226                 ndr->depth++;
27227                 ndr_print_ptr(ndr, "server", r->in.server);
27228                 ndr->depth++;
27229                 if (r->in.server) {
27230                         ndr_print_string(ndr, "server", r->in.server);
27231                 }
27232                 ndr->depth--;
27233                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27234                 ndr->depth++;
27235                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27236                 ndr->depth--;
27237                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27238                 ndr->depth++;
27239                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27240                 ndr->depth--;
27241                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27242                 ndr->depth++;
27243                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27244                 ndr->depth--;
27245                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27246                 ndr->depth++;
27247                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27248                 ndr->depth--;
27249                 ndr->depth--;
27250         }
27251         if (flags & NDR_OUT) {
27252                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27253                 ndr->depth++;
27254                 ndr_print_ptr(ndr, "handle", r->out.handle);
27255                 ndr->depth++;
27256                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27257                 ndr->depth--;
27258                 ndr_print_WERROR(ndr, "result", r->out.result);
27259                 ndr->depth--;
27260         }
27261         ndr->depth--;
27262 }
27263
27264 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27265 {
27266         if (flags & NDR_IN) {
27267         }
27268         if (flags & NDR_OUT) {
27269                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27270         }
27271         return NDR_ERR_SUCCESS;
27272 }
27273
27274 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27275 {
27276         if (flags & NDR_IN) {
27277         }
27278         if (flags & NDR_OUT) {
27279                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27280         }
27281         return NDR_ERR_SUCCESS;
27282 }
27283
27284 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27285 {
27286         ndr_print_struct(ndr, name, "spoolss_47");
27287         ndr->depth++;
27288         if (flags & NDR_SET_VALUES) {
27289                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27290         }
27291         if (flags & NDR_IN) {
27292                 ndr_print_struct(ndr, "in", "spoolss_47");
27293                 ndr->depth++;
27294                 ndr->depth--;
27295         }
27296         if (flags & NDR_OUT) {
27297                 ndr_print_struct(ndr, "out", "spoolss_47");
27298                 ndr->depth++;
27299                 ndr_print_WERROR(ndr, "result", r->out.result);
27300                 ndr->depth--;
27301         }
27302         ndr->depth--;
27303 }
27304
27305 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27306 {
27307         if (flags & NDR_IN) {
27308                 if (r->in.handle == NULL) {
27309                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27310                 }
27311                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27315         }
27316         if (flags & NDR_OUT) {
27317                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27318                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27319                 if (r->out.value_needed == NULL) {
27320                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27321                 }
27322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27323                 if (r->out.type == NULL) {
27324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27325                 }
27326                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27327                 {
27328                         uint32_t _flags_save_uint8 = ndr->flags;
27329                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27330                         if (r->out.data == NULL) {
27331                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27332                         }
27333                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27334                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27335                         ndr->flags = _flags_save_uint8;
27336                 }
27337                 if (r->out.data_needed == NULL) {
27338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27339                 }
27340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27342         }
27343         return NDR_ERR_SUCCESS;
27344 }
27345
27346 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27347 {
27348         TALLOC_CTX *_mem_save_handle_0;
27349         TALLOC_CTX *_mem_save_value_needed_0;
27350         TALLOC_CTX *_mem_save_type_0;
27351         TALLOC_CTX *_mem_save_data_needed_0;
27352         if (flags & NDR_IN) {
27353                 ZERO_STRUCT(r->out);
27354
27355                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27356                         NDR_PULL_ALLOC(ndr, r->in.handle);
27357                 }
27358                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27359                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27360                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27365                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27366                 ZERO_STRUCTP(r->out.value_needed);
27367                 NDR_PULL_ALLOC(ndr, r->out.type);
27368                 ZERO_STRUCTP(r->out.type);
27369                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27370                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27371                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27372                 ZERO_STRUCTP(r->out.data_needed);
27373         }
27374         if (flags & NDR_OUT) {
27375                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27376                 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));
27377                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27378                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27379                 }
27380                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27381                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27383                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27385                         NDR_PULL_ALLOC(ndr, r->out.type);
27386                 }
27387                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27388                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27389                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27391                 {
27392                         uint32_t _flags_save_uint8 = ndr->flags;
27393                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27394                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27395                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27396                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27397                         }
27398                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27399                         ndr->flags = _flags_save_uint8;
27400                 }
27401                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27402                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27403                 }
27404                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27405                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27407                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27408                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27409                 if (r->out.value_name) {
27410                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27411                 }
27412                 if (r->out.data) {
27413                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27414                 }
27415         }
27416         return NDR_ERR_SUCCESS;
27417 }
27418
27419 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27420 {
27421         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27422         ndr->depth++;
27423         if (flags & NDR_SET_VALUES) {
27424                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27425         }
27426         if (flags & NDR_IN) {
27427                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27428                 ndr->depth++;
27429                 ndr_print_ptr(ndr, "handle", r->in.handle);
27430                 ndr->depth++;
27431                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27432                 ndr->depth--;
27433                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27434                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27435                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27436                 ndr->depth--;
27437         }
27438         if (flags & NDR_OUT) {
27439                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27440                 ndr->depth++;
27441                 ndr_print_string(ndr, "value_name", r->out.value_name);
27442                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27443                 ndr->depth++;
27444                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27445                 ndr->depth--;
27446                 ndr_print_ptr(ndr, "type", r->out.type);
27447                 ndr->depth++;
27448                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27449                 ndr->depth--;
27450                 ndr_print_ptr(ndr, "data", r->out.data);
27451                 ndr->depth++;
27452                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27453                 ndr->depth--;
27454                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27455                 ndr->depth++;
27456                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27457                 ndr->depth--;
27458                 ndr_print_WERROR(ndr, "result", r->out.result);
27459                 ndr->depth--;
27460         }
27461         ndr->depth--;
27462 }
27463
27464 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27465 {
27466         if (flags & NDR_IN) {
27467                 if (r->in.handle == NULL) {
27468                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27469                 }
27470                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27471                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27472                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27473                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27474                 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));
27475         }
27476         if (flags & NDR_OUT) {
27477                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27478         }
27479         return NDR_ERR_SUCCESS;
27480 }
27481
27482 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27483 {
27484         TALLOC_CTX *_mem_save_handle_0;
27485         if (flags & NDR_IN) {
27486                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27487                         NDR_PULL_ALLOC(ndr, r->in.handle);
27488                 }
27489                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27490                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27491                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27492                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27493                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27494                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27495                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27496                         return 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));
27497                 }
27498                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27499                 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));
27500         }
27501         if (flags & NDR_OUT) {
27502                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27503         }
27504         return NDR_ERR_SUCCESS;
27505 }
27506
27507 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27508 {
27509         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27510         ndr->depth++;
27511         if (flags & NDR_SET_VALUES) {
27512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27513         }
27514         if (flags & NDR_IN) {
27515                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27516                 ndr->depth++;
27517                 ndr_print_ptr(ndr, "handle", r->in.handle);
27518                 ndr->depth++;
27519                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27520                 ndr->depth--;
27521                 ndr_print_string(ndr, "value_name", r->in.value_name);
27522                 ndr->depth--;
27523         }
27524         if (flags & NDR_OUT) {
27525                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27526                 ndr->depth++;
27527                 ndr_print_WERROR(ndr, "result", r->out.result);
27528                 ndr->depth--;
27529         }
27530         ndr->depth--;
27531 }
27532
27533 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27534 {
27535         if (flags & NDR_IN) {
27536         }
27537         if (flags & NDR_OUT) {
27538                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27539         }
27540         return NDR_ERR_SUCCESS;
27541 }
27542
27543 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
27544 {
27545         if (flags & NDR_IN) {
27546         }
27547         if (flags & NDR_OUT) {
27548                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27549         }
27550         return NDR_ERR_SUCCESS;
27551 }
27552
27553 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
27554 {
27555         ndr_print_struct(ndr, name, "spoolss_4a");
27556         ndr->depth++;
27557         if (flags & NDR_SET_VALUES) {
27558                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27559         }
27560         if (flags & NDR_IN) {
27561                 ndr_print_struct(ndr, "in", "spoolss_4a");
27562                 ndr->depth++;
27563                 ndr->depth--;
27564         }
27565         if (flags & NDR_OUT) {
27566                 ndr_print_struct(ndr, "out", "spoolss_4a");
27567                 ndr->depth++;
27568                 ndr_print_WERROR(ndr, "result", r->out.result);
27569                 ndr->depth--;
27570         }
27571         ndr->depth--;
27572 }
27573
27574 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27575 {
27576         if (flags & NDR_IN) {
27577         }
27578         if (flags & NDR_OUT) {
27579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27580         }
27581         return NDR_ERR_SUCCESS;
27582 }
27583
27584 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27585 {
27586         if (flags & NDR_IN) {
27587         }
27588         if (flags & NDR_OUT) {
27589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27590         }
27591         return NDR_ERR_SUCCESS;
27592 }
27593
27594 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27595 {
27596         ndr_print_struct(ndr, name, "spoolss_4b");
27597         ndr->depth++;
27598         if (flags & NDR_SET_VALUES) {
27599                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27600         }
27601         if (flags & NDR_IN) {
27602                 ndr_print_struct(ndr, "in", "spoolss_4b");
27603                 ndr->depth++;
27604                 ndr->depth--;
27605         }
27606         if (flags & NDR_OUT) {
27607                 ndr_print_struct(ndr, "out", "spoolss_4b");
27608                 ndr->depth++;
27609                 ndr_print_WERROR(ndr, "result", r->out.result);
27610                 ndr->depth--;
27611         }
27612         ndr->depth--;
27613 }
27614
27615 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27616 {
27617         if (flags & NDR_IN) {
27618         }
27619         if (flags & NDR_OUT) {
27620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27621         }
27622         return NDR_ERR_SUCCESS;
27623 }
27624
27625 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27626 {
27627         if (flags & NDR_IN) {
27628         }
27629         if (flags & NDR_OUT) {
27630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27631         }
27632         return NDR_ERR_SUCCESS;
27633 }
27634
27635 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27636 {
27637         ndr_print_struct(ndr, name, "spoolss_4c");
27638         ndr->depth++;
27639         if (flags & NDR_SET_VALUES) {
27640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27641         }
27642         if (flags & NDR_IN) {
27643                 ndr_print_struct(ndr, "in", "spoolss_4c");
27644                 ndr->depth++;
27645                 ndr->depth--;
27646         }
27647         if (flags & NDR_OUT) {
27648                 ndr_print_struct(ndr, "out", "spoolss_4c");
27649                 ndr->depth++;
27650                 ndr_print_WERROR(ndr, "result", r->out.result);
27651                 ndr->depth--;
27652         }
27653         ndr->depth--;
27654 }
27655
27656 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
27657 {
27658         if (flags & NDR_IN) {
27659                 if (r->in.handle == NULL) {
27660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27661                 }
27662                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27663                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27664                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27665                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27666                 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));
27667                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27668                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27669                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27670                 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));
27671                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27672                 if (r->in.buffer == NULL) {
27673                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27674                 }
27675                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27676                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
27677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27678         }
27679         if (flags & NDR_OUT) {
27680                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27681         }
27682         return NDR_ERR_SUCCESS;
27683 }
27684
27685 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
27686 {
27687         TALLOC_CTX *_mem_save_handle_0;
27688         if (flags & NDR_IN) {
27689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27690                         NDR_PULL_ALLOC(ndr, r->in.handle);
27691                 }
27692                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27693                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27694                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27696                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27697                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27698                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27699                         return 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));
27700                 }
27701                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27702                 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));
27703                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27704                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27705                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27706                         return 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));
27707                 }
27708                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27709                 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));
27710                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27711                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27712                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27713                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27714                 }
27715                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27717                 if (r->in.buffer) {
27718                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
27719                 }
27720         }
27721         if (flags & NDR_OUT) {
27722                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27723         }
27724         return NDR_ERR_SUCCESS;
27725 }
27726
27727 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
27728 {
27729         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
27730         ndr->depth++;
27731         if (flags & NDR_SET_VALUES) {
27732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27733         }
27734         if (flags & NDR_IN) {
27735                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
27736                 ndr->depth++;
27737                 ndr_print_ptr(ndr, "handle", r->in.handle);
27738                 ndr->depth++;
27739                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27740                 ndr->depth--;
27741                 ndr_print_string(ndr, "key_name", r->in.key_name);
27742                 ndr_print_string(ndr, "value_name", r->in.value_name);
27743                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27744                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27745                 ndr->depth++;
27746                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
27747                 ndr->depth--;
27748                 ndr_print_uint32(ndr, "offered", r->in.offered);
27749                 ndr->depth--;
27750         }
27751         if (flags & NDR_OUT) {
27752                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
27753                 ndr->depth++;
27754                 ndr_print_WERROR(ndr, "result", r->out.result);
27755                 ndr->depth--;
27756         }
27757         ndr->depth--;
27758 }
27759
27760 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
27761 {
27762         if (flags & NDR_IN) {
27763                 if (r->in.handle == NULL) {
27764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27765                 }
27766                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27767                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27768                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27769                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27770                 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));
27771                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27772                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27773                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27774                 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));
27775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27776         }
27777         if (flags & NDR_OUT) {
27778                 if (r->out.type == NULL) {
27779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27780                 }
27781                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27782                 if (r->out.buffer == NULL) {
27783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27784                 }
27785                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27786                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
27787                 if (r->out.needed == NULL) {
27788                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27789                 }
27790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27791                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27792         }
27793         return NDR_ERR_SUCCESS;
27794 }
27795
27796 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
27797 {
27798         TALLOC_CTX *_mem_save_handle_0;
27799         TALLOC_CTX *_mem_save_type_0;
27800         TALLOC_CTX *_mem_save_needed_0;
27801         if (flags & NDR_IN) {
27802                 ZERO_STRUCT(r->out);
27803
27804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27805                         NDR_PULL_ALLOC(ndr, r->in.handle);
27806                 }
27807                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27808                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27809                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27811                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27812                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27813                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27814                         return 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));
27815                 }
27816                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27817                 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));
27818                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27819                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27820                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27821                         return 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));
27822                 }
27823                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27824                 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));
27825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27826                 NDR_PULL_ALLOC(ndr, r->out.type);
27827                 ZERO_STRUCTP(r->out.type);
27828                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
27829                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
27830                 NDR_PULL_ALLOC(ndr, r->out.needed);
27831                 ZERO_STRUCTP(r->out.needed);
27832         }
27833         if (flags & NDR_OUT) {
27834                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27835                         NDR_PULL_ALLOC(ndr, r->out.type);
27836                 }
27837                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27838                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27839                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27841                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
27842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27843                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
27844                 }
27845                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
27846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27847                         NDR_PULL_ALLOC(ndr, r->out.needed);
27848                 }
27849                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27850                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27852                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27854                 if (r->out.buffer) {
27855                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
27856                 }
27857         }
27858         return NDR_ERR_SUCCESS;
27859 }
27860
27861 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
27862 {
27863         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
27864         ndr->depth++;
27865         if (flags & NDR_SET_VALUES) {
27866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27867         }
27868         if (flags & NDR_IN) {
27869                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
27870                 ndr->depth++;
27871                 ndr_print_ptr(ndr, "handle", r->in.handle);
27872                 ndr->depth++;
27873                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27874                 ndr->depth--;
27875                 ndr_print_string(ndr, "key_name", r->in.key_name);
27876                 ndr_print_string(ndr, "value_name", r->in.value_name);
27877                 ndr_print_uint32(ndr, "offered", r->in.offered);
27878                 ndr->depth--;
27879         }
27880         if (flags & NDR_OUT) {
27881                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
27882                 ndr->depth++;
27883                 ndr_print_ptr(ndr, "type", r->out.type);
27884                 ndr->depth++;
27885                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27886                 ndr->depth--;
27887                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
27888                 ndr->depth++;
27889                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
27890                 ndr->depth--;
27891                 ndr_print_ptr(ndr, "needed", r->out.needed);
27892                 ndr->depth++;
27893                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27894                 ndr->depth--;
27895                 ndr_print_WERROR(ndr, "result", r->out.result);
27896                 ndr->depth--;
27897         }
27898         ndr->depth--;
27899 }
27900
27901 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
27902 {
27903         if (flags & NDR_IN) {
27904                 if (r->in.handle == NULL) {
27905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27906                 }
27907                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27908                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27909                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27910                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27911                 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));
27912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27913         }
27914         if (flags & NDR_OUT) {
27915                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
27916                 if (r->out.needed == NULL) {
27917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27918                 }
27919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27920                 if (r->out.count == NULL) {
27921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27922                 }
27923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
27924                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27925         }
27926         return NDR_ERR_SUCCESS;
27927 }
27928
27929 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
27930 {
27931         TALLOC_CTX *_mem_save_handle_0;
27932         TALLOC_CTX *_mem_save_needed_0;
27933         TALLOC_CTX *_mem_save_count_0;
27934         if (flags & NDR_IN) {
27935                 ZERO_STRUCT(r->out);
27936
27937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27938                         NDR_PULL_ALLOC(ndr, r->in.handle);
27939                 }
27940                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27942                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27944                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27945                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27946                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27947                         return 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));
27948                 }
27949                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27950                 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));
27951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27952                 NDR_PULL_ALLOC(ndr, r->out.needed);
27953                 ZERO_STRUCTP(r->out.needed);
27954                 NDR_PULL_ALLOC(ndr, r->out.count);
27955                 ZERO_STRUCTP(r->out.count);
27956         }
27957         if (flags & NDR_OUT) {
27958                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
27959                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27960                         NDR_PULL_ALLOC(ndr, r->out.needed);
27961                 }
27962                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27963                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27967                         NDR_PULL_ALLOC(ndr, r->out.count);
27968                 }
27969                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
27970                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
27971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
27972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
27973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27974         }
27975         return NDR_ERR_SUCCESS;
27976 }
27977
27978 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
27979 {
27980         uint32_t cntr_info_0;
27981         if (flags & NDR_IN) {
27982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
27983         }
27984         if (flags & NDR_OUT) {
27985                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27986                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27987                 }
27988                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27989                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27990                 }
27991         }
27992         return NDR_ERR_SUCCESS;
27993 }
27994
27995 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
27996 {
27997         uint32_t cntr_info_0;
27998         TALLOC_CTX *_mem_save_info_0;
27999         if (flags & NDR_IN) {
28000                 ZERO_STRUCT(r->out);
28001
28002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28003         }
28004         if (flags & NDR_OUT) {
28005                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28006                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28007                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28008                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28009                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28010                 }
28011                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28012                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28013                 }
28014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28015         }
28016         return NDR_ERR_SUCCESS;
28017 }
28018
28019 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28020 {
28021         uint32_t cntr_info_2;
28022         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28023         ndr->depth++;
28024         if (flags & NDR_SET_VALUES) {
28025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28026         }
28027         if (flags & NDR_IN) {
28028                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28029                 ndr->depth++;
28030                 ndr_print_ptr(ndr, "handle", r->in.handle);
28031                 ndr->depth++;
28032                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28033                 ndr->depth--;
28034                 ndr_print_string(ndr, "key_name", r->in.key_name);
28035                 ndr_print_uint32(ndr, "offered", r->in.offered);
28036                 ndr->depth--;
28037         }
28038         if (flags & NDR_OUT) {
28039                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28040                 ndr->depth++;
28041                 ndr_print_ptr(ndr, "count", r->out.count);
28042                 ndr->depth++;
28043                 ndr_print_uint32(ndr, "count", *r->out.count);
28044                 ndr->depth--;
28045                 ndr_print_ptr(ndr, "info", r->out.info);
28046                 ndr->depth++;
28047                 ndr_print_ptr(ndr, "info", *r->out.info);
28048                 ndr->depth++;
28049                 if (*r->out.info) {
28050                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28051                         ndr->depth++;
28052                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28053                                 char *idx_2=NULL;
28054                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28055                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28056                                         free(idx_2);
28057                                 }
28058                         }
28059                         ndr->depth--;
28060                 }
28061                 ndr->depth--;
28062                 ndr->depth--;
28063                 ndr_print_ptr(ndr, "needed", r->out.needed);
28064                 ndr->depth++;
28065                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28066                 ndr->depth--;
28067                 ndr_print_WERROR(ndr, "result", r->out.result);
28068                 ndr->depth--;
28069         }
28070         ndr->depth--;
28071 }
28072
28073 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28074 {
28075         uint32_t cntr_key_buffer_1;
28076         if (flags & NDR_IN) {
28077                 if (r->in.handle == NULL) {
28078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28079                 }
28080                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28081                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28082                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28083                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28084                 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));
28085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28086         }
28087         if (flags & NDR_OUT) {
28088                 if (r->out.key_buffer == NULL) {
28089                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28090                 }
28091                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered / 2));
28092                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.offered / 2; cntr_key_buffer_1++) {
28093                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
28094                 }
28095                 if (r->out.needed == NULL) {
28096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28097                 }
28098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28099                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28100         }
28101         return NDR_ERR_SUCCESS;
28102 }
28103
28104 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28105 {
28106         uint32_t cntr_key_buffer_1;
28107         TALLOC_CTX *_mem_save_handle_0;
28108         TALLOC_CTX *_mem_save_key_buffer_1;
28109         TALLOC_CTX *_mem_save_needed_0;
28110         if (flags & NDR_IN) {
28111                 ZERO_STRUCT(r->out);
28112
28113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28114                         NDR_PULL_ALLOC(ndr, r->in.handle);
28115                 }
28116                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28117                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28118                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28120                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28121                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28122                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28123                         return 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));
28124                 }
28125                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28126                 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));
28127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28128                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.offered / 2);
28129                 memset(r->out.key_buffer, 0, (r->in.offered / 2) * sizeof(*r->out.key_buffer));
28130                 NDR_PULL_ALLOC(ndr, r->out.needed);
28131                 ZERO_STRUCTP(r->out.needed);
28132         }
28133         if (flags & NDR_OUT) {
28134                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
28135                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28136                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
28137                 }
28138                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
28139                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
28140                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.offered / 2; cntr_key_buffer_1++) {
28141                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
28142                 }
28143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
28144                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28145                         NDR_PULL_ALLOC(ndr, r->out.needed);
28146                 }
28147                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28148                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28150                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28151                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28152                 if (r->out.key_buffer) {
28153                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.offered / 2));
28154                 }
28155         }
28156         return NDR_ERR_SUCCESS;
28157 }
28158
28159 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28160 {
28161         uint32_t cntr_key_buffer_1;
28162         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28163         ndr->depth++;
28164         if (flags & NDR_SET_VALUES) {
28165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28166         }
28167         if (flags & NDR_IN) {
28168                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28169                 ndr->depth++;
28170                 ndr_print_ptr(ndr, "handle", r->in.handle);
28171                 ndr->depth++;
28172                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28173                 ndr->depth--;
28174                 ndr_print_string(ndr, "key_name", r->in.key_name);
28175                 ndr_print_uint32(ndr, "offered", r->in.offered);
28176                 ndr->depth--;
28177         }
28178         if (flags & NDR_OUT) {
28179                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28180                 ndr->depth++;
28181                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28182                 ndr->depth++;
28183                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.offered / 2);
28184                 ndr->depth++;
28185                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.offered / 2;cntr_key_buffer_1++) {
28186                         char *idx_1=NULL;
28187                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
28188                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
28189                                 free(idx_1);
28190                         }
28191                 }
28192                 ndr->depth--;
28193                 ndr->depth--;
28194                 ndr_print_ptr(ndr, "needed", r->out.needed);
28195                 ndr->depth++;
28196                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28197                 ndr->depth--;
28198                 ndr_print_WERROR(ndr, "result", r->out.result);
28199                 ndr->depth--;
28200         }
28201         ndr->depth--;
28202 }
28203
28204 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28205 {
28206         if (flags & NDR_IN) {
28207                 if (r->in.handle == NULL) {
28208                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28209                 }
28210                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28211                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28212                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28213                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28214                 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));
28215                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28216                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28217                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28218                 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));
28219         }
28220         if (flags & NDR_OUT) {
28221                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28222         }
28223         return NDR_ERR_SUCCESS;
28224 }
28225
28226 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28227 {
28228         TALLOC_CTX *_mem_save_handle_0;
28229         if (flags & NDR_IN) {
28230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28231                         NDR_PULL_ALLOC(ndr, r->in.handle);
28232                 }
28233                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28234                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28235                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28237                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28238                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28239                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28240                         return 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));
28241                 }
28242                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28243                 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));
28244                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28245                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28246                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28247                         return 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));
28248                 }
28249                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28250                 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));
28251         }
28252         if (flags & NDR_OUT) {
28253                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28254         }
28255         return NDR_ERR_SUCCESS;
28256 }
28257
28258 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28259 {
28260         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28261         ndr->depth++;
28262         if (flags & NDR_SET_VALUES) {
28263                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28264         }
28265         if (flags & NDR_IN) {
28266                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28267                 ndr->depth++;
28268                 ndr_print_ptr(ndr, "handle", r->in.handle);
28269                 ndr->depth++;
28270                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28271                 ndr->depth--;
28272                 ndr_print_string(ndr, "key_name", r->in.key_name);
28273                 ndr_print_string(ndr, "value_name", r->in.value_name);
28274                 ndr->depth--;
28275         }
28276         if (flags & NDR_OUT) {
28277                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28278                 ndr->depth++;
28279                 ndr_print_WERROR(ndr, "result", r->out.result);
28280                 ndr->depth--;
28281         }
28282         ndr->depth--;
28283 }
28284
28285 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28286 {
28287         if (flags & NDR_IN) {
28288                 if (r->in.handle == NULL) {
28289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28290                 }
28291                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28292                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28293                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28294                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28295                 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));
28296         }
28297         if (flags & NDR_OUT) {
28298                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28299         }
28300         return NDR_ERR_SUCCESS;
28301 }
28302
28303 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28304 {
28305         TALLOC_CTX *_mem_save_handle_0;
28306         if (flags & NDR_IN) {
28307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28308                         NDR_PULL_ALLOC(ndr, r->in.handle);
28309                 }
28310                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28311                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28312                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28314                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28315                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28316                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28317                         return 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));
28318                 }
28319                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28320                 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));
28321         }
28322         if (flags & NDR_OUT) {
28323                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28324         }
28325         return NDR_ERR_SUCCESS;
28326 }
28327
28328 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28329 {
28330         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28331         ndr->depth++;
28332         if (flags & NDR_SET_VALUES) {
28333                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28334         }
28335         if (flags & NDR_IN) {
28336                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28337                 ndr->depth++;
28338                 ndr_print_ptr(ndr, "handle", r->in.handle);
28339                 ndr->depth++;
28340                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28341                 ndr->depth--;
28342                 ndr_print_string(ndr, "key_name", r->in.key_name);
28343                 ndr->depth--;
28344         }
28345         if (flags & NDR_OUT) {
28346                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28347                 ndr->depth++;
28348                 ndr_print_WERROR(ndr, "result", r->out.result);
28349                 ndr->depth--;
28350         }
28351         ndr->depth--;
28352 }
28353
28354 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28355 {
28356         if (flags & NDR_IN) {
28357         }
28358         if (flags & NDR_OUT) {
28359                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28360         }
28361         return NDR_ERR_SUCCESS;
28362 }
28363
28364 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28365 {
28366         if (flags & NDR_IN) {
28367         }
28368         if (flags & NDR_OUT) {
28369                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28370         }
28371         return NDR_ERR_SUCCESS;
28372 }
28373
28374 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28375 {
28376         ndr_print_struct(ndr, name, "spoolss_53");
28377         ndr->depth++;
28378         if (flags & NDR_SET_VALUES) {
28379                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28380         }
28381         if (flags & NDR_IN) {
28382                 ndr_print_struct(ndr, "in", "spoolss_53");
28383                 ndr->depth++;
28384                 ndr->depth--;
28385         }
28386         if (flags & NDR_OUT) {
28387                 ndr_print_struct(ndr, "out", "spoolss_53");
28388                 ndr->depth++;
28389                 ndr_print_WERROR(ndr, "result", r->out.result);
28390                 ndr->depth--;
28391         }
28392         ndr->depth--;
28393 }
28394
28395 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28396 {
28397         if (flags & NDR_IN) {
28398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28399                 if (r->in.server) {
28400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28404                 }
28405                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28406                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28407                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28408                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28409                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28410                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28411                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28412                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28413                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28415         }
28416         if (flags & NDR_OUT) {
28417                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28418         }
28419         return NDR_ERR_SUCCESS;
28420 }
28421
28422 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28423 {
28424         uint32_t _ptr_server;
28425         TALLOC_CTX *_mem_save_server_0;
28426         if (flags & NDR_IN) {
28427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28428                 if (_ptr_server) {
28429                         NDR_PULL_ALLOC(ndr, r->in.server);
28430                 } else {
28431                         r->in.server = NULL;
28432                 }
28433                 if (r->in.server) {
28434                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28435                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28436                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28437                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28438                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28439                                 return 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));
28440                         }
28441                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28442                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28444                 }
28445                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28446                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28447                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28448                         return 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));
28449                 }
28450                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28451                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28452                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28453                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28454                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28455                         return 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));
28456                 }
28457                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28458                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28459                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28461         }
28462         if (flags & NDR_OUT) {
28463                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28464         }
28465         return NDR_ERR_SUCCESS;
28466 }
28467
28468 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28469 {
28470         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28471         ndr->depth++;
28472         if (flags & NDR_SET_VALUES) {
28473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28474         }
28475         if (flags & NDR_IN) {
28476                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28477                 ndr->depth++;
28478                 ndr_print_ptr(ndr, "server", r->in.server);
28479                 ndr->depth++;
28480                 if (r->in.server) {
28481                         ndr_print_string(ndr, "server", r->in.server);
28482                 }
28483                 ndr->depth--;
28484                 ndr_print_string(ndr, "architecture", r->in.architecture);
28485                 ndr_print_string(ndr, "driver", r->in.driver);
28486                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
28487                 ndr_print_uint32(ndr, "version", r->in.version);
28488                 ndr->depth--;
28489         }
28490         if (flags & NDR_OUT) {
28491                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
28492                 ndr->depth++;
28493                 ndr_print_WERROR(ndr, "result", r->out.result);
28494                 ndr->depth--;
28495         }
28496         ndr->depth--;
28497 }
28498
28499 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
28500 {
28501         if (flags & NDR_IN) {
28502         }
28503         if (flags & NDR_OUT) {
28504                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28505         }
28506         return NDR_ERR_SUCCESS;
28507 }
28508
28509 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
28510 {
28511         if (flags & NDR_IN) {
28512         }
28513         if (flags & NDR_OUT) {
28514                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28515         }
28516         return NDR_ERR_SUCCESS;
28517 }
28518
28519 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
28520 {
28521         ndr_print_struct(ndr, name, "spoolss_55");
28522         ndr->depth++;
28523         if (flags & NDR_SET_VALUES) {
28524                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28525         }
28526         if (flags & NDR_IN) {
28527                 ndr_print_struct(ndr, "in", "spoolss_55");
28528                 ndr->depth++;
28529                 ndr->depth--;
28530         }
28531         if (flags & NDR_OUT) {
28532                 ndr_print_struct(ndr, "out", "spoolss_55");
28533                 ndr->depth++;
28534                 ndr_print_WERROR(ndr, "result", r->out.result);
28535                 ndr->depth--;
28536         }
28537         ndr->depth--;
28538 }
28539
28540 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
28541 {
28542         if (flags & NDR_IN) {
28543         }
28544         if (flags & NDR_OUT) {
28545                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28546         }
28547         return NDR_ERR_SUCCESS;
28548 }
28549
28550 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
28551 {
28552         if (flags & NDR_IN) {
28553         }
28554         if (flags & NDR_OUT) {
28555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28556         }
28557         return NDR_ERR_SUCCESS;
28558 }
28559
28560 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28561 {
28562         ndr_print_struct(ndr, name, "spoolss_56");
28563         ndr->depth++;
28564         if (flags & NDR_SET_VALUES) {
28565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28566         }
28567         if (flags & NDR_IN) {
28568                 ndr_print_struct(ndr, "in", "spoolss_56");
28569                 ndr->depth++;
28570                 ndr->depth--;
28571         }
28572         if (flags & NDR_OUT) {
28573                 ndr_print_struct(ndr, "out", "spoolss_56");
28574                 ndr->depth++;
28575                 ndr_print_WERROR(ndr, "result", r->out.result);
28576                 ndr->depth--;
28577         }
28578         ndr->depth--;
28579 }
28580
28581 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28582 {
28583         if (flags & NDR_IN) {
28584         }
28585         if (flags & NDR_OUT) {
28586                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28587         }
28588         return NDR_ERR_SUCCESS;
28589 }
28590
28591 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28592 {
28593         if (flags & NDR_IN) {
28594         }
28595         if (flags & NDR_OUT) {
28596                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28597         }
28598         return NDR_ERR_SUCCESS;
28599 }
28600
28601 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28602 {
28603         ndr_print_struct(ndr, name, "spoolss_57");
28604         ndr->depth++;
28605         if (flags & NDR_SET_VALUES) {
28606                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28607         }
28608         if (flags & NDR_IN) {
28609                 ndr_print_struct(ndr, "in", "spoolss_57");
28610                 ndr->depth++;
28611                 ndr->depth--;
28612         }
28613         if (flags & NDR_OUT) {
28614                 ndr_print_struct(ndr, "out", "spoolss_57");
28615                 ndr->depth++;
28616                 ndr_print_WERROR(ndr, "result", r->out.result);
28617                 ndr->depth--;
28618         }
28619         ndr->depth--;
28620 }
28621
28622 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
28623 {
28624         if (flags & NDR_IN) {
28625                 if (r->in.handle == NULL) {
28626                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28627                 }
28628                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28629                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28630                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28631                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28632                 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));
28633                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
28634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
28635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28636                 if (r->in.status_code == NULL) {
28637                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28638                 }
28639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
28640         }
28641         if (flags & NDR_OUT) {
28642                 if (r->out.out_data == NULL) {
28643                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28644                 }
28645                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
28646                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
28647                 if (r->out.needed == NULL) {
28648                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28649                 }
28650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28651                 if (r->out.status_code == NULL) {
28652                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28653                 }
28654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
28655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28656         }
28657         return NDR_ERR_SUCCESS;
28658 }
28659
28660 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
28661 {
28662         TALLOC_CTX *_mem_save_handle_0;
28663         TALLOC_CTX *_mem_save_needed_0;
28664         TALLOC_CTX *_mem_save_status_code_0;
28665         if (flags & NDR_IN) {
28666                 ZERO_STRUCT(r->out);
28667
28668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28669                         NDR_PULL_ALLOC(ndr, r->in.handle);
28670                 }
28671                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28672                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28673                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28675                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
28676                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
28677                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
28678                         return 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));
28679                 }
28680                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
28681                 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));
28682                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
28683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
28684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
28685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28686                         NDR_PULL_ALLOC(ndr, r->in.status_code);
28687                 }
28688                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
28690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
28691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28692                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
28693                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
28694                 NDR_PULL_ALLOC(ndr, r->out.needed);
28695                 ZERO_STRUCTP(r->out.needed);
28696                 NDR_PULL_ALLOC(ndr, r->out.status_code);
28697                 *r->out.status_code = *r->in.status_code;
28698         }
28699         if (flags & NDR_OUT) {
28700                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
28701                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28702                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
28703                 }
28704                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
28705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28706                         NDR_PULL_ALLOC(ndr, r->out.needed);
28707                 }
28708                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28709                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28712                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28713                         NDR_PULL_ALLOC(ndr, r->out.status_code);
28714                 }
28715                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28716                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
28717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
28718                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28719                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28720                 if (r->out.out_data) {
28721                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
28722                 }
28723         }
28724         return NDR_ERR_SUCCESS;
28725 }
28726
28727 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
28728 {
28729         ndr_print_struct(ndr, name, "spoolss_XcvData");
28730         ndr->depth++;
28731         if (flags & NDR_SET_VALUES) {
28732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28733         }
28734         if (flags & NDR_IN) {
28735                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
28736                 ndr->depth++;
28737                 ndr_print_ptr(ndr, "handle", r->in.handle);
28738                 ndr->depth++;
28739                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28740                 ndr->depth--;
28741                 ndr_print_string(ndr, "function_name", r->in.function_name);
28742                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
28743                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
28744                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
28745                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
28746                 ndr->depth++;
28747                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
28748                 ndr->depth--;
28749                 ndr->depth--;
28750         }
28751         if (flags & NDR_OUT) {
28752                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
28753                 ndr->depth++;
28754                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
28755                 ndr->depth++;
28756                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
28757                 ndr->depth--;
28758                 ndr_print_ptr(ndr, "needed", r->out.needed);
28759                 ndr->depth++;
28760                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28761                 ndr->depth--;
28762                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
28763                 ndr->depth++;
28764                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
28765                 ndr->depth--;
28766                 ndr_print_WERROR(ndr, "result", r->out.result);
28767                 ndr->depth--;
28768         }
28769         ndr->depth--;
28770 }
28771
28772 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
28773 {
28774         if (flags & NDR_IN) {
28775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28776                 if (r->in.servername) {
28777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28780                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28781                 }
28782                 if (r->in.info_ctr == NULL) {
28783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28784                 }
28785                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28786                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
28787         }
28788         if (flags & NDR_OUT) {
28789                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28790         }
28791         return NDR_ERR_SUCCESS;
28792 }
28793
28794 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
28795 {
28796         uint32_t _ptr_servername;
28797         TALLOC_CTX *_mem_save_servername_0;
28798         TALLOC_CTX *_mem_save_info_ctr_0;
28799         if (flags & NDR_IN) {
28800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28801                 if (_ptr_servername) {
28802                         NDR_PULL_ALLOC(ndr, r->in.servername);
28803                 } else {
28804                         r->in.servername = NULL;
28805                 }
28806                 if (r->in.servername) {
28807                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28808                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28809                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28810                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28811                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28812                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
28813                         }
28814                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28815                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28817                 }
28818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28819                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28820                 }
28821                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28822                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28823                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28825                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
28826         }
28827         if (flags & NDR_OUT) {
28828                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28829         }
28830         return NDR_ERR_SUCCESS;
28831 }
28832
28833 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
28834 {
28835         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
28836         ndr->depth++;
28837         if (flags & NDR_SET_VALUES) {
28838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28839         }
28840         if (flags & NDR_IN) {
28841                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
28842                 ndr->depth++;
28843                 ndr_print_ptr(ndr, "servername", r->in.servername);
28844                 ndr->depth++;
28845                 if (r->in.servername) {
28846                         ndr_print_string(ndr, "servername", r->in.servername);
28847                 }
28848                 ndr->depth--;
28849                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28850                 ndr->depth++;
28851                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28852                 ndr->depth--;
28853                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
28854                 ndr->depth--;
28855         }
28856         if (flags & NDR_OUT) {
28857                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
28858                 ndr->depth++;
28859                 ndr_print_WERROR(ndr, "result", r->out.result);
28860                 ndr->depth--;
28861         }
28862         ndr->depth--;
28863 }
28864
28865 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
28866 {
28867         if (flags & NDR_IN) {
28868         }
28869         if (flags & NDR_OUT) {
28870                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28871         }
28872         return NDR_ERR_SUCCESS;
28873 }
28874
28875 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
28876 {
28877         if (flags & NDR_IN) {
28878         }
28879         if (flags & NDR_OUT) {
28880                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28881         }
28882         return NDR_ERR_SUCCESS;
28883 }
28884
28885 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
28886 {
28887         ndr_print_struct(ndr, name, "spoolss_5a");
28888         ndr->depth++;
28889         if (flags & NDR_SET_VALUES) {
28890                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28891         }
28892         if (flags & NDR_IN) {
28893                 ndr_print_struct(ndr, "in", "spoolss_5a");
28894                 ndr->depth++;
28895                 ndr->depth--;
28896         }
28897         if (flags & NDR_OUT) {
28898                 ndr_print_struct(ndr, "out", "spoolss_5a");
28899                 ndr->depth++;
28900                 ndr_print_WERROR(ndr, "result", r->out.result);
28901                 ndr->depth--;
28902         }
28903         ndr->depth--;
28904 }
28905
28906 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
28907 {
28908         if (flags & NDR_IN) {
28909         }
28910         if (flags & NDR_OUT) {
28911                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28912         }
28913         return NDR_ERR_SUCCESS;
28914 }
28915
28916 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
28917 {
28918         if (flags & NDR_IN) {
28919         }
28920         if (flags & NDR_OUT) {
28921                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28922         }
28923         return NDR_ERR_SUCCESS;
28924 }
28925
28926 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
28927 {
28928         ndr_print_struct(ndr, name, "spoolss_5b");
28929         ndr->depth++;
28930         if (flags & NDR_SET_VALUES) {
28931                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28932         }
28933         if (flags & NDR_IN) {
28934                 ndr_print_struct(ndr, "in", "spoolss_5b");
28935                 ndr->depth++;
28936                 ndr->depth--;
28937         }
28938         if (flags & NDR_OUT) {
28939                 ndr_print_struct(ndr, "out", "spoolss_5b");
28940                 ndr->depth++;
28941                 ndr_print_WERROR(ndr, "result", r->out.result);
28942                 ndr->depth--;
28943         }
28944         ndr->depth--;
28945 }
28946
28947 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
28948 {
28949         if (flags & NDR_IN) {
28950         }
28951         if (flags & NDR_OUT) {
28952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28953         }
28954         return NDR_ERR_SUCCESS;
28955 }
28956
28957 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
28958 {
28959         if (flags & NDR_IN) {
28960         }
28961         if (flags & NDR_OUT) {
28962                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28963         }
28964         return NDR_ERR_SUCCESS;
28965 }
28966
28967 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
28968 {
28969         ndr_print_struct(ndr, name, "spoolss_5c");
28970         ndr->depth++;
28971         if (flags & NDR_SET_VALUES) {
28972                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28973         }
28974         if (flags & NDR_IN) {
28975                 ndr_print_struct(ndr, "in", "spoolss_5c");
28976                 ndr->depth++;
28977                 ndr->depth--;
28978         }
28979         if (flags & NDR_OUT) {
28980                 ndr_print_struct(ndr, "out", "spoolss_5c");
28981                 ndr->depth++;
28982                 ndr_print_WERROR(ndr, "result", r->out.result);
28983                 ndr->depth--;
28984         }
28985         ndr->depth--;
28986 }
28987
28988 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
28989 {
28990         if (flags & NDR_IN) {
28991         }
28992         if (flags & NDR_OUT) {
28993                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28994         }
28995         return NDR_ERR_SUCCESS;
28996 }
28997
28998 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
28999 {
29000         if (flags & NDR_IN) {
29001         }
29002         if (flags & NDR_OUT) {
29003                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29004         }
29005         return NDR_ERR_SUCCESS;
29006 }
29007
29008 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29009 {
29010         ndr_print_struct(ndr, name, "spoolss_5d");
29011         ndr->depth++;
29012         if (flags & NDR_SET_VALUES) {
29013                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29014         }
29015         if (flags & NDR_IN) {
29016                 ndr_print_struct(ndr, "in", "spoolss_5d");
29017                 ndr->depth++;
29018                 ndr->depth--;
29019         }
29020         if (flags & NDR_OUT) {
29021                 ndr_print_struct(ndr, "out", "spoolss_5d");
29022                 ndr->depth++;
29023                 ndr_print_WERROR(ndr, "result", r->out.result);
29024                 ndr->depth--;
29025         }
29026         ndr->depth--;
29027 }
29028
29029 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29030 {
29031         if (flags & NDR_IN) {
29032         }
29033         if (flags & NDR_OUT) {
29034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29035         }
29036         return NDR_ERR_SUCCESS;
29037 }
29038
29039 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29040 {
29041         if (flags & NDR_IN) {
29042         }
29043         if (flags & NDR_OUT) {
29044                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29045         }
29046         return NDR_ERR_SUCCESS;
29047 }
29048
29049 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29050 {
29051         ndr_print_struct(ndr, name, "spoolss_5e");
29052         ndr->depth++;
29053         if (flags & NDR_SET_VALUES) {
29054                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29055         }
29056         if (flags & NDR_IN) {
29057                 ndr_print_struct(ndr, "in", "spoolss_5e");
29058                 ndr->depth++;
29059                 ndr->depth--;
29060         }
29061         if (flags & NDR_OUT) {
29062                 ndr_print_struct(ndr, "out", "spoolss_5e");
29063                 ndr->depth++;
29064                 ndr_print_WERROR(ndr, "result", r->out.result);
29065                 ndr->depth--;
29066         }
29067         ndr->depth--;
29068 }
29069
29070 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29071 {
29072         if (flags & NDR_IN) {
29073         }
29074         if (flags & NDR_OUT) {
29075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29076         }
29077         return NDR_ERR_SUCCESS;
29078 }
29079
29080 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29081 {
29082         if (flags & NDR_IN) {
29083         }
29084         if (flags & NDR_OUT) {
29085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29086         }
29087         return NDR_ERR_SUCCESS;
29088 }
29089
29090 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29091 {
29092         ndr_print_struct(ndr, name, "spoolss_5f");
29093         ndr->depth++;
29094         if (flags & NDR_SET_VALUES) {
29095                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29096         }
29097         if (flags & NDR_IN) {
29098                 ndr_print_struct(ndr, "in", "spoolss_5f");
29099                 ndr->depth++;
29100                 ndr->depth--;
29101         }
29102         if (flags & NDR_OUT) {
29103                 ndr_print_struct(ndr, "out", "spoolss_5f");
29104                 ndr->depth++;
29105                 ndr_print_WERROR(ndr, "result", r->out.result);
29106                 ndr->depth--;
29107         }
29108         ndr->depth--;
29109 }
29110
29111 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29112 {
29113         if (flags & NDR_IN) {
29114         }
29115         if (flags & NDR_OUT) {
29116                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29117         }
29118         return NDR_ERR_SUCCESS;
29119 }
29120
29121 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29122 {
29123         if (flags & NDR_IN) {
29124         }
29125         if (flags & NDR_OUT) {
29126                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29127         }
29128         return NDR_ERR_SUCCESS;
29129 }
29130
29131 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29132 {
29133         ndr_print_struct(ndr, name, "spoolss_60");
29134         ndr->depth++;
29135         if (flags & NDR_SET_VALUES) {
29136                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29137         }
29138         if (flags & NDR_IN) {
29139                 ndr_print_struct(ndr, "in", "spoolss_60");
29140                 ndr->depth++;
29141                 ndr->depth--;
29142         }
29143         if (flags & NDR_OUT) {
29144                 ndr_print_struct(ndr, "out", "spoolss_60");
29145                 ndr->depth++;
29146                 ndr_print_WERROR(ndr, "result", r->out.result);
29147                 ndr->depth--;
29148         }
29149         ndr->depth--;
29150 }
29151
29152 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29153 {
29154         if (flags & NDR_IN) {
29155         }
29156         if (flags & NDR_OUT) {
29157                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29158         }
29159         return NDR_ERR_SUCCESS;
29160 }
29161
29162 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29163 {
29164         if (flags & NDR_IN) {
29165         }
29166         if (flags & NDR_OUT) {
29167                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29168         }
29169         return NDR_ERR_SUCCESS;
29170 }
29171
29172 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29173 {
29174         ndr_print_struct(ndr, name, "spoolss_61");
29175         ndr->depth++;
29176         if (flags & NDR_SET_VALUES) {
29177                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29178         }
29179         if (flags & NDR_IN) {
29180                 ndr_print_struct(ndr, "in", "spoolss_61");
29181                 ndr->depth++;
29182                 ndr->depth--;
29183         }
29184         if (flags & NDR_OUT) {
29185                 ndr_print_struct(ndr, "out", "spoolss_61");
29186                 ndr->depth++;
29187                 ndr_print_WERROR(ndr, "result", r->out.result);
29188                 ndr->depth--;
29189         }
29190         ndr->depth--;
29191 }
29192
29193 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29194 {
29195         if (flags & NDR_IN) {
29196         }
29197         if (flags & NDR_OUT) {
29198                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29199         }
29200         return NDR_ERR_SUCCESS;
29201 }
29202
29203 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29204 {
29205         if (flags & NDR_IN) {
29206         }
29207         if (flags & NDR_OUT) {
29208                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29209         }
29210         return NDR_ERR_SUCCESS;
29211 }
29212
29213 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29214 {
29215         ndr_print_struct(ndr, name, "spoolss_62");
29216         ndr->depth++;
29217         if (flags & NDR_SET_VALUES) {
29218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29219         }
29220         if (flags & NDR_IN) {
29221                 ndr_print_struct(ndr, "in", "spoolss_62");
29222                 ndr->depth++;
29223                 ndr->depth--;
29224         }
29225         if (flags & NDR_OUT) {
29226                 ndr_print_struct(ndr, "out", "spoolss_62");
29227                 ndr->depth++;
29228                 ndr_print_WERROR(ndr, "result", r->out.result);
29229                 ndr->depth--;
29230         }
29231         ndr->depth--;
29232 }
29233
29234 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29235 {
29236         if (flags & NDR_IN) {
29237         }
29238         if (flags & NDR_OUT) {
29239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29240         }
29241         return NDR_ERR_SUCCESS;
29242 }
29243
29244 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29245 {
29246         if (flags & NDR_IN) {
29247         }
29248         if (flags & NDR_OUT) {
29249                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29250         }
29251         return NDR_ERR_SUCCESS;
29252 }
29253
29254 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29255 {
29256         ndr_print_struct(ndr, name, "spoolss_63");
29257         ndr->depth++;
29258         if (flags & NDR_SET_VALUES) {
29259                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29260         }
29261         if (flags & NDR_IN) {
29262                 ndr_print_struct(ndr, "in", "spoolss_63");
29263                 ndr->depth++;
29264                 ndr->depth--;
29265         }
29266         if (flags & NDR_OUT) {
29267                 ndr_print_struct(ndr, "out", "spoolss_63");
29268                 ndr->depth++;
29269                 ndr_print_WERROR(ndr, "result", r->out.result);
29270                 ndr->depth--;
29271         }
29272         ndr->depth--;
29273 }
29274
29275 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29276 {
29277         if (flags & NDR_IN) {
29278         }
29279         if (flags & NDR_OUT) {
29280                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29281         }
29282         return NDR_ERR_SUCCESS;
29283 }
29284
29285 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29286 {
29287         if (flags & NDR_IN) {
29288         }
29289         if (flags & NDR_OUT) {
29290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29291         }
29292         return NDR_ERR_SUCCESS;
29293 }
29294
29295 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29296 {
29297         ndr_print_struct(ndr, name, "spoolss_64");
29298         ndr->depth++;
29299         if (flags & NDR_SET_VALUES) {
29300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29301         }
29302         if (flags & NDR_IN) {
29303                 ndr_print_struct(ndr, "in", "spoolss_64");
29304                 ndr->depth++;
29305                 ndr->depth--;
29306         }
29307         if (flags & NDR_OUT) {
29308                 ndr_print_struct(ndr, "out", "spoolss_64");
29309                 ndr->depth++;
29310                 ndr_print_WERROR(ndr, "result", r->out.result);
29311                 ndr->depth--;
29312         }
29313         ndr->depth--;
29314 }
29315
29316 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29317 {
29318         if (flags & NDR_IN) {
29319         }
29320         if (flags & NDR_OUT) {
29321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29322         }
29323         return NDR_ERR_SUCCESS;
29324 }
29325
29326 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29327 {
29328         if (flags & NDR_IN) {
29329         }
29330         if (flags & NDR_OUT) {
29331                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29332         }
29333         return NDR_ERR_SUCCESS;
29334 }
29335
29336 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29337 {
29338         ndr_print_struct(ndr, name, "spoolss_65");
29339         ndr->depth++;
29340         if (flags & NDR_SET_VALUES) {
29341                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29342         }
29343         if (flags & NDR_IN) {
29344                 ndr_print_struct(ndr, "in", "spoolss_65");
29345                 ndr->depth++;
29346                 ndr->depth--;
29347         }
29348         if (flags & NDR_OUT) {
29349                 ndr_print_struct(ndr, "out", "spoolss_65");
29350                 ndr->depth++;
29351                 ndr_print_WERROR(ndr, "result", r->out.result);
29352                 ndr->depth--;
29353         }
29354         ndr->depth--;
29355 }
29356
29357 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29358 {
29359         uint32_t cntr_core_printer_drivers_1;
29360         if (flags & NDR_IN) {
29361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29362                 if (r->in.servername) {
29363                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29364                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29365                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29366                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29367                 }
29368                 if (r->in.architecture == NULL) {
29369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29370                 }
29371                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29372                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29373                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29374                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29376                 if (r->in.core_driver_dependencies == NULL) {
29377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29378                 }
29379                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29380                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29382         }
29383         if (flags & NDR_OUT) {
29384                 if (r->out.core_printer_drivers == NULL) {
29385                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29386                 }
29387                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29388                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29389                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29390                 }
29391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29392         }
29393         return NDR_ERR_SUCCESS;
29394 }
29395
29396 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29397 {
29398         uint32_t _ptr_servername;
29399         uint32_t cntr_core_printer_drivers_1;
29400         TALLOC_CTX *_mem_save_servername_0;
29401         TALLOC_CTX *_mem_save_core_printer_drivers_1;
29402         if (flags & NDR_IN) {
29403                 ZERO_STRUCT(r->out);
29404
29405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29406                 if (_ptr_servername) {
29407                         NDR_PULL_ALLOC(ndr, r->in.servername);
29408                 } else {
29409                         r->in.servername = NULL;
29410                 }
29411                 if (r->in.servername) {
29412                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29413                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29416                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29417                                 return 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));
29418                         }
29419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29422                 }
29423                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29424                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29425                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29426                         return 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));
29427                 }
29428                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29429                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29431                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29432                 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));
29433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29434                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29435                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29436                 if (r->in.core_driver_dependencies) {
29437                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29438                 }
29439         }
29440         if (flags & NDR_OUT) {
29441                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29442                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29443                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29444                 }
29445                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29446                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29447                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29448                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29449                 }
29450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29451                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29452                 if (r->out.core_printer_drivers) {
29453                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29454                 }
29455         }
29456         return NDR_ERR_SUCCESS;
29457 }
29458
29459 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29460 {
29461         uint32_t cntr_core_printer_drivers_1;
29462         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29463         ndr->depth++;
29464         if (flags & NDR_SET_VALUES) {
29465                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29466         }
29467         if (flags & NDR_IN) {
29468                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29469                 ndr->depth++;
29470                 ndr_print_ptr(ndr, "servername", r->in.servername);
29471                 ndr->depth++;
29472                 if (r->in.servername) {
29473                         ndr_print_string(ndr, "servername", r->in.servername);
29474                 }
29475                 ndr->depth--;
29476                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29477                 ndr->depth++;
29478                 ndr_print_string(ndr, "architecture", r->in.architecture);
29479                 ndr->depth--;
29480                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
29481                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29482                 ndr->depth++;
29483                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29484                 ndr->depth--;
29485                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
29486                 ndr->depth--;
29487         }
29488         if (flags & NDR_OUT) {
29489                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
29490                 ndr->depth++;
29491                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
29492                 ndr->depth++;
29493                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
29494                 ndr->depth++;
29495                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
29496                         char *idx_1=NULL;
29497                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
29498                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
29499                                 free(idx_1);
29500                         }
29501                 }
29502                 ndr->depth--;
29503                 ndr->depth--;
29504                 ndr_print_WERROR(ndr, "result", r->out.result);
29505                 ndr->depth--;
29506         }
29507         ndr->depth--;
29508 }
29509
29510 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
29511 {
29512         if (flags & NDR_IN) {
29513         }
29514         if (flags & NDR_OUT) {
29515                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29516         }
29517         return NDR_ERR_SUCCESS;
29518 }
29519
29520 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
29521 {
29522         if (flags & NDR_IN) {
29523         }
29524         if (flags & NDR_OUT) {
29525                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29526         }
29527         return NDR_ERR_SUCCESS;
29528 }
29529
29530 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
29531 {
29532         ndr_print_struct(ndr, name, "spoolss_67");
29533         ndr->depth++;
29534         if (flags & NDR_SET_VALUES) {
29535                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29536         }
29537         if (flags & NDR_IN) {
29538                 ndr_print_struct(ndr, "in", "spoolss_67");
29539                 ndr->depth++;
29540                 ndr->depth--;
29541         }
29542         if (flags & NDR_OUT) {
29543                 ndr_print_struct(ndr, "out", "spoolss_67");
29544                 ndr->depth++;
29545                 ndr_print_WERROR(ndr, "result", r->out.result);
29546                 ndr->depth--;
29547         }
29548         ndr->depth--;
29549 }
29550
29551 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29552 {
29553         if (flags & NDR_IN) {
29554                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29555                 if (r->in.servername) {
29556                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29557                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29559                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29560                 }
29561                 if (r->in.architecture == NULL) {
29562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29563                 }
29564                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29565                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29566                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29567                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29568                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29569                 if (r->in.language) {
29570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29571                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29572                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29573                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29574                 }
29575                 if (r->in.package_id == NULL) {
29576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29577                 }
29578                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29579                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29580                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29581                 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));
29582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29583                 if (r->in.driver_package_cab) {
29584                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29585                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29586                 }
29587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29588         }
29589         if (flags & NDR_OUT) {
29590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29591                 if (r->out.driver_package_cab) {
29592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29593                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29594                 }
29595                 if (r->out.required == NULL) {
29596                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29597                 }
29598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29599                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29600         }
29601         return NDR_ERR_SUCCESS;
29602 }
29603
29604 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29605 {
29606         uint32_t _ptr_servername;
29607         uint32_t _ptr_language;
29608         uint32_t _ptr_driver_package_cab;
29609         TALLOC_CTX *_mem_save_servername_0;
29610         TALLOC_CTX *_mem_save_language_0;
29611         TALLOC_CTX *_mem_save_driver_package_cab_0;
29612         TALLOC_CTX *_mem_save_required_0;
29613         if (flags & NDR_IN) {
29614                 ZERO_STRUCT(r->out);
29615
29616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29617                 if (_ptr_servername) {
29618                         NDR_PULL_ALLOC(ndr, r->in.servername);
29619                 } else {
29620                         r->in.servername = NULL;
29621                 }
29622                 if (r->in.servername) {
29623                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29624                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29625                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29626                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29627                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29628                                 return 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));
29629                         }
29630                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29631                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29633                 }
29634                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29635                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29636                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29637                         return 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));
29638                 }
29639                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29640                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
29642                 if (_ptr_language) {
29643                         NDR_PULL_ALLOC(ndr, r->in.language);
29644                 } else {
29645                         r->in.language = NULL;
29646                 }
29647                 if (r->in.language) {
29648                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
29649                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
29650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
29651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
29652                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
29653                                 return 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));
29654                         }
29655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
29656                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
29657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
29658                 }
29659                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
29660                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
29661                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
29662                         return 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));
29663                 }
29664                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
29665                 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));
29666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29667                 if (_ptr_driver_package_cab) {
29668                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
29669                 } else {
29670                         r->in.driver_package_cab = NULL;
29671                 }
29672                 if (r->in.driver_package_cab) {
29673                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29674                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
29675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
29676                         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));
29677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29678                 }
29679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
29680                 NDR_PULL_ALLOC(ndr, r->out.required);
29681                 ZERO_STRUCTP(r->out.required);
29682                 if (r->in.driver_package_cab) {
29683                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
29684                 }
29685         }
29686         if (flags & NDR_OUT) {
29687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29688                 if (_ptr_driver_package_cab) {
29689                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
29690                 } else {
29691                         r->out.driver_package_cab = NULL;
29692                 }
29693                 if (r->out.driver_package_cab) {
29694                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29695                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
29696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
29697                         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));
29698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29699                 }
29700                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29701                         NDR_PULL_ALLOC(ndr, r->out.required);
29702                 }
29703                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
29704                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
29705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
29706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
29707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29708                 if (r->out.driver_package_cab) {
29709                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
29710                 }
29711         }
29712         return NDR_ERR_SUCCESS;
29713 }
29714
29715 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29716 {
29717         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
29718         ndr->depth++;
29719         if (flags & NDR_SET_VALUES) {
29720                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29721         }
29722         if (flags & NDR_IN) {
29723                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
29724                 ndr->depth++;
29725                 ndr_print_ptr(ndr, "servername", r->in.servername);
29726                 ndr->depth++;
29727                 if (r->in.servername) {
29728                         ndr_print_string(ndr, "servername", r->in.servername);
29729                 }
29730                 ndr->depth--;
29731                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29732                 ndr->depth++;
29733                 ndr_print_string(ndr, "architecture", r->in.architecture);
29734                 ndr->depth--;
29735                 ndr_print_ptr(ndr, "language", r->in.language);
29736                 ndr->depth++;
29737                 if (r->in.language) {
29738                         ndr_print_string(ndr, "language", r->in.language);
29739                 }
29740                 ndr->depth--;
29741                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
29742                 ndr->depth++;
29743                 ndr_print_string(ndr, "package_id", r->in.package_id);
29744                 ndr->depth--;
29745                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
29746                 ndr->depth++;
29747                 if (r->in.driver_package_cab) {
29748                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
29749                 }
29750                 ndr->depth--;
29751                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
29752                 ndr->depth--;
29753         }
29754         if (flags & NDR_OUT) {
29755                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
29756                 ndr->depth++;
29757                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
29758                 ndr->depth++;
29759                 if (r->out.driver_package_cab) {
29760                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
29761                 }
29762                 ndr->depth--;
29763                 ndr_print_ptr(ndr, "required", r->out.required);
29764                 ndr->depth++;
29765                 ndr_print_uint32(ndr, "required", *r->out.required);
29766                 ndr->depth--;
29767                 ndr_print_WERROR(ndr, "result", r->out.result);
29768                 ndr->depth--;
29769         }
29770         ndr->depth--;
29771 }
29772
29773 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
29774 {
29775         if (flags & NDR_IN) {
29776         }
29777         if (flags & NDR_OUT) {
29778                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29779         }
29780         return NDR_ERR_SUCCESS;
29781 }
29782
29783 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
29784 {
29785         if (flags & NDR_IN) {
29786         }
29787         if (flags & NDR_OUT) {
29788                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29789         }
29790         return NDR_ERR_SUCCESS;
29791 }
29792
29793 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
29794 {
29795         ndr_print_struct(ndr, name, "spoolss_69");
29796         ndr->depth++;
29797         if (flags & NDR_SET_VALUES) {
29798                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29799         }
29800         if (flags & NDR_IN) {
29801                 ndr_print_struct(ndr, "in", "spoolss_69");
29802                 ndr->depth++;
29803                 ndr->depth--;
29804         }
29805         if (flags & NDR_OUT) {
29806                 ndr_print_struct(ndr, "out", "spoolss_69");
29807                 ndr->depth++;
29808                 ndr_print_WERROR(ndr, "result", r->out.result);
29809                 ndr->depth--;
29810         }
29811         ndr->depth--;
29812 }
29813
29814 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
29815 {
29816         if (flags & NDR_IN) {
29817         }
29818         if (flags & NDR_OUT) {
29819                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29820         }
29821         return NDR_ERR_SUCCESS;
29822 }
29823
29824 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
29825 {
29826         if (flags & NDR_IN) {
29827         }
29828         if (flags & NDR_OUT) {
29829                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29830         }
29831         return NDR_ERR_SUCCESS;
29832 }
29833
29834 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
29835 {
29836         ndr_print_struct(ndr, name, "spoolss_6a");
29837         ndr->depth++;
29838         if (flags & NDR_SET_VALUES) {
29839                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29840         }
29841         if (flags & NDR_IN) {
29842                 ndr_print_struct(ndr, "in", "spoolss_6a");
29843                 ndr->depth++;
29844                 ndr->depth--;
29845         }
29846         if (flags & NDR_OUT) {
29847                 ndr_print_struct(ndr, "out", "spoolss_6a");
29848                 ndr->depth++;
29849                 ndr_print_WERROR(ndr, "result", r->out.result);
29850                 ndr->depth--;
29851         }
29852         ndr->depth--;
29853 }
29854
29855 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
29856 {
29857         if (flags & NDR_IN) {
29858         }
29859         if (flags & NDR_OUT) {
29860                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29861         }
29862         return NDR_ERR_SUCCESS;
29863 }
29864
29865 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
29866 {
29867         if (flags & NDR_IN) {
29868         }
29869         if (flags & NDR_OUT) {
29870                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29871         }
29872         return NDR_ERR_SUCCESS;
29873 }
29874
29875 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
29876 {
29877         ndr_print_struct(ndr, name, "spoolss_6b");
29878         ndr->depth++;
29879         if (flags & NDR_SET_VALUES) {
29880                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29881         }
29882         if (flags & NDR_IN) {
29883                 ndr_print_struct(ndr, "in", "spoolss_6b");
29884                 ndr->depth++;
29885                 ndr->depth--;
29886         }
29887         if (flags & NDR_OUT) {
29888                 ndr_print_struct(ndr, "out", "spoolss_6b");
29889                 ndr->depth++;
29890                 ndr_print_WERROR(ndr, "result", r->out.result);
29891                 ndr->depth--;
29892         }
29893         ndr->depth--;
29894 }
29895
29896 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
29897 {
29898         if (flags & NDR_IN) {
29899         }
29900         if (flags & NDR_OUT) {
29901                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29902         }
29903         return NDR_ERR_SUCCESS;
29904 }
29905
29906 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
29907 {
29908         if (flags & NDR_IN) {
29909         }
29910         if (flags & NDR_OUT) {
29911                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29912         }
29913         return NDR_ERR_SUCCESS;
29914 }
29915
29916 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
29917 {
29918         ndr_print_struct(ndr, name, "spoolss_6c");
29919         ndr->depth++;
29920         if (flags & NDR_SET_VALUES) {
29921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29922         }
29923         if (flags & NDR_IN) {
29924                 ndr_print_struct(ndr, "in", "spoolss_6c");
29925                 ndr->depth++;
29926                 ndr->depth--;
29927         }
29928         if (flags & NDR_OUT) {
29929                 ndr_print_struct(ndr, "out", "spoolss_6c");
29930                 ndr->depth++;
29931                 ndr_print_WERROR(ndr, "result", r->out.result);
29932                 ndr->depth--;
29933         }
29934         ndr->depth--;
29935 }
29936
29937 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
29938 {
29939         if (flags & NDR_IN) {
29940         }
29941         if (flags & NDR_OUT) {
29942                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29943         }
29944         return NDR_ERR_SUCCESS;
29945 }
29946
29947 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
29948 {
29949         if (flags & NDR_IN) {
29950         }
29951         if (flags & NDR_OUT) {
29952                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29953         }
29954         return NDR_ERR_SUCCESS;
29955 }
29956
29957 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
29958 {
29959         ndr_print_struct(ndr, name, "spoolss_6d");
29960         ndr->depth++;
29961         if (flags & NDR_SET_VALUES) {
29962                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29963         }
29964         if (flags & NDR_IN) {
29965                 ndr_print_struct(ndr, "in", "spoolss_6d");
29966                 ndr->depth++;
29967                 ndr->depth--;
29968         }
29969         if (flags & NDR_OUT) {
29970                 ndr_print_struct(ndr, "out", "spoolss_6d");
29971                 ndr->depth++;
29972                 ndr_print_WERROR(ndr, "result", r->out.result);
29973                 ndr->depth--;
29974         }
29975         ndr->depth--;
29976 }
29977
29978 static const struct ndr_interface_call spoolss_calls[] = {
29979         {
29980                 "spoolss_EnumPrinters",
29981                 sizeof(struct spoolss_EnumPrinters),
29982                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
29983                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
29984                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
29985                 false,
29986         },
29987         {
29988                 "spoolss_OpenPrinter",
29989                 sizeof(struct spoolss_OpenPrinter),
29990                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
29991                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
29992                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
29993                 false,
29994         },
29995         {
29996                 "spoolss_SetJob",
29997                 sizeof(struct spoolss_SetJob),
29998                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
29999                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30000                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30001                 false,
30002         },
30003         {
30004                 "spoolss_GetJob",
30005                 sizeof(struct spoolss_GetJob),
30006                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30007                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30008                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30009                 false,
30010         },
30011         {
30012                 "spoolss_EnumJobs",
30013                 sizeof(struct spoolss_EnumJobs),
30014                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30015                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30016                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30017                 false,
30018         },
30019         {
30020                 "spoolss_AddPrinter",
30021                 sizeof(struct spoolss_AddPrinter),
30022                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30023                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30024                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30025                 false,
30026         },
30027         {
30028                 "spoolss_DeletePrinter",
30029                 sizeof(struct spoolss_DeletePrinter),
30030                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30031                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30032                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30033                 false,
30034         },
30035         {
30036                 "spoolss_SetPrinter",
30037                 sizeof(struct spoolss_SetPrinter),
30038                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30039                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30040                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30041                 false,
30042         },
30043         {
30044                 "spoolss_GetPrinter",
30045                 sizeof(struct spoolss_GetPrinter),
30046                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30047                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30048                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30049                 false,
30050         },
30051         {
30052                 "spoolss_AddPrinterDriver",
30053                 sizeof(struct spoolss_AddPrinterDriver),
30054                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30055                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30056                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30057                 false,
30058         },
30059         {
30060                 "spoolss_EnumPrinterDrivers",
30061                 sizeof(struct spoolss_EnumPrinterDrivers),
30062                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30063                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30064                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30065                 false,
30066         },
30067         {
30068                 "spoolss_GetPrinterDriver",
30069                 sizeof(struct spoolss_GetPrinterDriver),
30070                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30071                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30072                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30073                 false,
30074         },
30075         {
30076                 "spoolss_GetPrinterDriverDirectory",
30077                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30078                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30079                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30080                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30081                 false,
30082         },
30083         {
30084                 "spoolss_DeletePrinterDriver",
30085                 sizeof(struct spoolss_DeletePrinterDriver),
30086                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30087                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30088                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30089                 false,
30090         },
30091         {
30092                 "spoolss_AddPrintProcessor",
30093                 sizeof(struct spoolss_AddPrintProcessor),
30094                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30095                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30096                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30097                 false,
30098         },
30099         {
30100                 "spoolss_EnumPrintProcessors",
30101                 sizeof(struct spoolss_EnumPrintProcessors),
30102                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30103                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30104                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30105                 false,
30106         },
30107         {
30108                 "spoolss_GetPrintProcessorDirectory",
30109                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30110                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30111                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30112                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30113                 false,
30114         },
30115         {
30116                 "spoolss_StartDocPrinter",
30117                 sizeof(struct spoolss_StartDocPrinter),
30118                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30119                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30120                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30121                 false,
30122         },
30123         {
30124                 "spoolss_StartPagePrinter",
30125                 sizeof(struct spoolss_StartPagePrinter),
30126                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30127                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30128                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30129                 false,
30130         },
30131         {
30132                 "spoolss_WritePrinter",
30133                 sizeof(struct spoolss_WritePrinter),
30134                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30135                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30136                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30137                 false,
30138         },
30139         {
30140                 "spoolss_EndPagePrinter",
30141                 sizeof(struct spoolss_EndPagePrinter),
30142                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30143                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30144                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30145                 false,
30146         },
30147         {
30148                 "spoolss_AbortPrinter",
30149                 sizeof(struct spoolss_AbortPrinter),
30150                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30151                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30152                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30153                 false,
30154         },
30155         {
30156                 "spoolss_ReadPrinter",
30157                 sizeof(struct spoolss_ReadPrinter),
30158                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30159                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30160                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30161                 false,
30162         },
30163         {
30164                 "spoolss_EndDocPrinter",
30165                 sizeof(struct spoolss_EndDocPrinter),
30166                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30167                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30168                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30169                 false,
30170         },
30171         {
30172                 "spoolss_AddJob",
30173                 sizeof(struct spoolss_AddJob),
30174                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30175                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30176                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
30177                 false,
30178         },
30179         {
30180                 "spoolss_ScheduleJob",
30181                 sizeof(struct spoolss_ScheduleJob),
30182                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30183                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30184                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30185                 false,
30186         },
30187         {
30188                 "spoolss_GetPrinterData",
30189                 sizeof(struct spoolss_GetPrinterData),
30190                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30191                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30192                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30193                 false,
30194         },
30195         {
30196                 "spoolss_SetPrinterData",
30197                 sizeof(struct spoolss_SetPrinterData),
30198                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30199                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30200                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30201                 false,
30202         },
30203         {
30204                 "spoolss_WaitForPrinterChange",
30205                 sizeof(struct spoolss_WaitForPrinterChange),
30206                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30207                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30208                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30209                 false,
30210         },
30211         {
30212                 "spoolss_ClosePrinter",
30213                 sizeof(struct spoolss_ClosePrinter),
30214                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30215                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30216                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30217                 false,
30218         },
30219         {
30220                 "spoolss_AddForm",
30221                 sizeof(struct spoolss_AddForm),
30222                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30223                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30224                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
30225                 false,
30226         },
30227         {
30228                 "spoolss_DeleteForm",
30229                 sizeof(struct spoolss_DeleteForm),
30230                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30231                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30232                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30233                 false,
30234         },
30235         {
30236                 "spoolss_GetForm",
30237                 sizeof(struct spoolss_GetForm),
30238                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30239                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30240                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
30241                 false,
30242         },
30243         {
30244                 "spoolss_SetForm",
30245                 sizeof(struct spoolss_SetForm),
30246                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30247                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30248                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
30249                 false,
30250         },
30251         {
30252                 "spoolss_EnumForms",
30253                 sizeof(struct spoolss_EnumForms),
30254                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30255                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30256                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30257                 false,
30258         },
30259         {
30260                 "spoolss_EnumPorts",
30261                 sizeof(struct spoolss_EnumPorts),
30262                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30263                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30264                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30265                 false,
30266         },
30267         {
30268                 "spoolss_EnumMonitors",
30269                 sizeof(struct spoolss_EnumMonitors),
30270                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30271                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30272                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30273                 false,
30274         },
30275         {
30276                 "spoolss_AddPort",
30277                 sizeof(struct spoolss_AddPort),
30278                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30279                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30280                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30281                 false,
30282         },
30283         {
30284                 "spoolss_ConfigurePort",
30285                 sizeof(struct spoolss_ConfigurePort),
30286                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30287                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30288                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30289                 false,
30290         },
30291         {
30292                 "spoolss_DeletePort",
30293                 sizeof(struct spoolss_DeletePort),
30294                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30295                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30296                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30297                 false,
30298         },
30299         {
30300                 "spoolss_CreatePrinterIC",
30301                 sizeof(struct spoolss_CreatePrinterIC),
30302                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30303                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30304                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30305                 false,
30306         },
30307         {
30308                 "spoolss_PlayGDIScriptOnPrinterIC",
30309                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30310                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30311                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30312                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30313                 false,
30314         },
30315         {
30316                 "spoolss_DeletePrinterIC",
30317                 sizeof(struct spoolss_DeletePrinterIC),
30318                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30319                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30320                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30321                 false,
30322         },
30323         {
30324                 "spoolss_AddPrinterConnection",
30325                 sizeof(struct spoolss_AddPrinterConnection),
30326                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30327                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30328                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30329                 false,
30330         },
30331         {
30332                 "spoolss_DeletePrinterConnection",
30333                 sizeof(struct spoolss_DeletePrinterConnection),
30334                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30335                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30336                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30337                 false,
30338         },
30339         {
30340                 "spoolss_PrinterMessageBox",
30341                 sizeof(struct spoolss_PrinterMessageBox),
30342                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30343                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30344                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30345                 false,
30346         },
30347         {
30348                 "spoolss_AddMonitor",
30349                 sizeof(struct spoolss_AddMonitor),
30350                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30351                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30352                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30353                 false,
30354         },
30355         {
30356                 "spoolss_DeleteMonitor",
30357                 sizeof(struct spoolss_DeleteMonitor),
30358                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30359                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30360                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30361                 false,
30362         },
30363         {
30364                 "spoolss_DeletePrintProcessor",
30365                 sizeof(struct spoolss_DeletePrintProcessor),
30366                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30367                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30368                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30369                 false,
30370         },
30371         {
30372                 "spoolss_AddPrintProvidor",
30373                 sizeof(struct spoolss_AddPrintProvidor),
30374                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30375                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30376                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30377                 false,
30378         },
30379         {
30380                 "spoolss_DeletePrintProvidor",
30381                 sizeof(struct spoolss_DeletePrintProvidor),
30382                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30383                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30384                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30385                 false,
30386         },
30387         {
30388                 "spoolss_EnumPrintProcDataTypes",
30389                 sizeof(struct spoolss_EnumPrintProcDataTypes),
30390                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30391                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30392                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30393                 false,
30394         },
30395         {
30396                 "spoolss_ResetPrinter",
30397                 sizeof(struct spoolss_ResetPrinter),
30398                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30399                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30400                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30401                 false,
30402         },
30403         {
30404                 "spoolss_GetPrinterDriver2",
30405                 sizeof(struct spoolss_GetPrinterDriver2),
30406                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30407                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30408                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30409                 false,
30410         },
30411         {
30412                 "spoolss_FindFirstPrinterChangeNotification",
30413                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30414                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30415                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30416                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30417                 false,
30418         },
30419         {
30420                 "spoolss_FindNextPrinterChangeNotification",
30421                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
30422                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30423                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30424                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30425                 false,
30426         },
30427         {
30428                 "spoolss_FindClosePrinterNotify",
30429                 sizeof(struct spoolss_FindClosePrinterNotify),
30430                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30431                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30432                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30433                 false,
30434         },
30435         {
30436                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30437                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30438                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30439                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30440                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30441                 false,
30442         },
30443         {
30444                 "spoolss_ReplyOpenPrinter",
30445                 sizeof(struct spoolss_ReplyOpenPrinter),
30446                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30447                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30448                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30449                 false,
30450         },
30451         {
30452                 "spoolss_RouterReplyPrinter",
30453                 sizeof(struct spoolss_RouterReplyPrinter),
30454                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30455                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30456                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30457                 false,
30458         },
30459         {
30460                 "spoolss_ReplyClosePrinter",
30461                 sizeof(struct spoolss_ReplyClosePrinter),
30462                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30463                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30464                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30465                 false,
30466         },
30467         {
30468                 "spoolss_AddPortEx",
30469                 sizeof(struct spoolss_AddPortEx),
30470                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30471                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30472                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30473                 false,
30474         },
30475         {
30476                 "spoolss_RouterFindFirstPrinterChangeNotification",
30477                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30478                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30479                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30480                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
30481                 false,
30482         },
30483         {
30484                 "spoolss_SpoolerInit",
30485                 sizeof(struct spoolss_SpoolerInit),
30486                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
30487                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
30488                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
30489                 false,
30490         },
30491         {
30492                 "spoolss_ResetPrinterEx",
30493                 sizeof(struct spoolss_ResetPrinterEx),
30494                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
30495                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
30496                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
30497                 false,
30498         },
30499         {
30500                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
30501                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
30502                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30503                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30504                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30505                 false,
30506         },
30507         {
30508                 "spoolss_RouterReplyPrinterEx",
30509                 sizeof(struct spoolss_RouterReplyPrinterEx),
30510                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
30511                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
30512                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
30513                 false,
30514         },
30515         {
30516                 "spoolss_RouterRefreshPrinterChangeNotify",
30517                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
30518                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
30519                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
30520                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
30521                 false,
30522         },
30523         {
30524                 "spoolss_44",
30525                 sizeof(struct spoolss_44),
30526                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
30527                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
30528                 (ndr_print_function_t) ndr_print_spoolss_44,
30529                 false,
30530         },
30531         {
30532                 "spoolss_OpenPrinterEx",
30533                 sizeof(struct spoolss_OpenPrinterEx),
30534                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
30535                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
30536                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
30537                 false,
30538         },
30539         {
30540                 "spoolss_AddPrinterEx",
30541                 sizeof(struct spoolss_AddPrinterEx),
30542                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
30543                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
30544                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
30545                 false,
30546         },
30547         {
30548                 "spoolss_47",
30549                 sizeof(struct spoolss_47),
30550                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
30551                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30552                 (ndr_print_function_t) ndr_print_spoolss_47,
30553                 false,
30554         },
30555         {
30556                 "spoolss_EnumPrinterData",
30557                 sizeof(struct spoolss_EnumPrinterData),
30558                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30559                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30560                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30561                 false,
30562         },
30563         {
30564                 "spoolss_DeletePrinterData",
30565                 sizeof(struct spoolss_DeletePrinterData),
30566                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30567                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30568                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30569                 false,
30570         },
30571         {
30572                 "spoolss_4a",
30573                 sizeof(struct spoolss_4a),
30574                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30575                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30576                 (ndr_print_function_t) ndr_print_spoolss_4a,
30577                 false,
30578         },
30579         {
30580                 "spoolss_4b",
30581                 sizeof(struct spoolss_4b),
30582                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30583                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30584                 (ndr_print_function_t) ndr_print_spoolss_4b,
30585                 false,
30586         },
30587         {
30588                 "spoolss_4c",
30589                 sizeof(struct spoolss_4c),
30590                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30591                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30592                 (ndr_print_function_t) ndr_print_spoolss_4c,
30593                 false,
30594         },
30595         {
30596                 "spoolss_SetPrinterDataEx",
30597                 sizeof(struct spoolss_SetPrinterDataEx),
30598                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30599                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30600                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30601                 false,
30602         },
30603         {
30604                 "spoolss_GetPrinterDataEx",
30605                 sizeof(struct spoolss_GetPrinterDataEx),
30606                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30607                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30608                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30609                 false,
30610         },
30611         {
30612                 "spoolss_EnumPrinterDataEx",
30613                 sizeof(struct spoolss_EnumPrinterDataEx),
30614                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30615                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30616                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30617                 false,
30618         },
30619         {
30620                 "spoolss_EnumPrinterKey",
30621                 sizeof(struct spoolss_EnumPrinterKey),
30622                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
30623                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
30624                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
30625                 false,
30626         },
30627         {
30628                 "spoolss_DeletePrinterDataEx",
30629                 sizeof(struct spoolss_DeletePrinterDataEx),
30630                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
30631                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
30632                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
30633                 false,
30634         },
30635         {
30636                 "spoolss_DeletePrinterKey",
30637                 sizeof(struct spoolss_DeletePrinterKey),
30638                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
30639                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
30640                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
30641                 false,
30642         },
30643         {
30644                 "spoolss_53",
30645                 sizeof(struct spoolss_53),
30646                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
30647                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
30648                 (ndr_print_function_t) ndr_print_spoolss_53,
30649                 false,
30650         },
30651         {
30652                 "spoolss_DeletePrinterDriverEx",
30653                 sizeof(struct spoolss_DeletePrinterDriverEx),
30654                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
30655                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
30656                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
30657                 false,
30658         },
30659         {
30660                 "spoolss_55",
30661                 sizeof(struct spoolss_55),
30662                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
30663                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
30664                 (ndr_print_function_t) ndr_print_spoolss_55,
30665                 false,
30666         },
30667         {
30668                 "spoolss_56",
30669                 sizeof(struct spoolss_56),
30670                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
30671                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
30672                 (ndr_print_function_t) ndr_print_spoolss_56,
30673                 false,
30674         },
30675         {
30676                 "spoolss_57",
30677                 sizeof(struct spoolss_57),
30678                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
30679                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
30680                 (ndr_print_function_t) ndr_print_spoolss_57,
30681                 false,
30682         },
30683         {
30684                 "spoolss_XcvData",
30685                 sizeof(struct spoolss_XcvData),
30686                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
30687                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
30688                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
30689                 false,
30690         },
30691         {
30692                 "spoolss_AddPrinterDriverEx",
30693                 sizeof(struct spoolss_AddPrinterDriverEx),
30694                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
30695                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
30696                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
30697                 false,
30698         },
30699         {
30700                 "spoolss_5a",
30701                 sizeof(struct spoolss_5a),
30702                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
30703                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
30704                 (ndr_print_function_t) ndr_print_spoolss_5a,
30705                 false,
30706         },
30707         {
30708                 "spoolss_5b",
30709                 sizeof(struct spoolss_5b),
30710                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
30711                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
30712                 (ndr_print_function_t) ndr_print_spoolss_5b,
30713                 false,
30714         },
30715         {
30716                 "spoolss_5c",
30717                 sizeof(struct spoolss_5c),
30718                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
30719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
30720                 (ndr_print_function_t) ndr_print_spoolss_5c,
30721                 false,
30722         },
30723         {
30724                 "spoolss_5d",
30725                 sizeof(struct spoolss_5d),
30726                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
30727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
30728                 (ndr_print_function_t) ndr_print_spoolss_5d,
30729                 false,
30730         },
30731         {
30732                 "spoolss_5e",
30733                 sizeof(struct spoolss_5e),
30734                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
30735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
30736                 (ndr_print_function_t) ndr_print_spoolss_5e,
30737                 false,
30738         },
30739         {
30740                 "spoolss_5f",
30741                 sizeof(struct spoolss_5f),
30742                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
30743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
30744                 (ndr_print_function_t) ndr_print_spoolss_5f,
30745                 false,
30746         },
30747         {
30748                 "spoolss_60",
30749                 sizeof(struct spoolss_60),
30750                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
30751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
30752                 (ndr_print_function_t) ndr_print_spoolss_60,
30753                 false,
30754         },
30755         {
30756                 "spoolss_61",
30757                 sizeof(struct spoolss_61),
30758                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
30759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
30760                 (ndr_print_function_t) ndr_print_spoolss_61,
30761                 false,
30762         },
30763         {
30764                 "spoolss_62",
30765                 sizeof(struct spoolss_62),
30766                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
30767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
30768                 (ndr_print_function_t) ndr_print_spoolss_62,
30769                 false,
30770         },
30771         {
30772                 "spoolss_63",
30773                 sizeof(struct spoolss_63),
30774                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
30775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
30776                 (ndr_print_function_t) ndr_print_spoolss_63,
30777                 false,
30778         },
30779         {
30780                 "spoolss_64",
30781                 sizeof(struct spoolss_64),
30782                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
30783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
30784                 (ndr_print_function_t) ndr_print_spoolss_64,
30785                 false,
30786         },
30787         {
30788                 "spoolss_65",
30789                 sizeof(struct spoolss_65),
30790                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
30791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
30792                 (ndr_print_function_t) ndr_print_spoolss_65,
30793                 false,
30794         },
30795         {
30796                 "spoolss_GetCorePrinterDrivers",
30797                 sizeof(struct spoolss_GetCorePrinterDrivers),
30798                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
30799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
30800                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
30801                 false,
30802         },
30803         {
30804                 "spoolss_67",
30805                 sizeof(struct spoolss_67),
30806                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
30807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
30808                 (ndr_print_function_t) ndr_print_spoolss_67,
30809                 false,
30810         },
30811         {
30812                 "spoolss_GetPrinterDriverPackagePath",
30813                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
30814                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
30815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
30816                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
30817                 false,
30818         },
30819         {
30820                 "spoolss_69",
30821                 sizeof(struct spoolss_69),
30822                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
30823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
30824                 (ndr_print_function_t) ndr_print_spoolss_69,
30825                 false,
30826         },
30827         {
30828                 "spoolss_6a",
30829                 sizeof(struct spoolss_6a),
30830                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
30831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
30832                 (ndr_print_function_t) ndr_print_spoolss_6a,
30833                 false,
30834         },
30835         {
30836                 "spoolss_6b",
30837                 sizeof(struct spoolss_6b),
30838                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
30839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
30840                 (ndr_print_function_t) ndr_print_spoolss_6b,
30841                 false,
30842         },
30843         {
30844                 "spoolss_6c",
30845                 sizeof(struct spoolss_6c),
30846                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
30847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
30848                 (ndr_print_function_t) ndr_print_spoolss_6c,
30849                 false,
30850         },
30851         {
30852                 "spoolss_6d",
30853                 sizeof(struct spoolss_6d),
30854                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
30855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
30856                 (ndr_print_function_t) ndr_print_spoolss_6d,
30857                 false,
30858         },
30859         { NULL, 0, NULL, NULL, NULL, false }
30860 };
30861
30862 static const char * const spoolss_endpoint_strings[] = {
30863         "ncacn_np:[\\pipe\\spoolss]",
30864 };
30865
30866 static const struct ndr_interface_string_array spoolss_endpoints = {
30867         .count  = 1,
30868         .names  = spoolss_endpoint_strings
30869 };
30870
30871 static const char * const spoolss_authservice_strings[] = {
30872         "host",
30873 };
30874
30875 static const struct ndr_interface_string_array spoolss_authservices = {
30876         .count  = 1,
30877         .names  = spoolss_authservice_strings
30878 };
30879
30880
30881 const struct ndr_interface_table ndr_table_spoolss = {
30882         .name           = "spoolss",
30883         .syntax_id      = {
30884                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
30885                 NDR_SPOOLSS_VERSION
30886         },
30887         .helpstring     = NDR_SPOOLSS_HELPSTRING,
30888         .num_calls      = 110,
30889         .calls          = spoolss_calls,
30890         .endpoints      = &spoolss_endpoints,
30891         .authservices   = &spoolss_authservices
30892 };
30893