librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  48 {
  49         ndr_print_struct(ndr, name, "spoolss_Time");
  50         ndr->depth++;
  51         ndr_print_uint16(ndr, "year", r->year);
  52         ndr_print_uint16(ndr, "month", r->month);
  53         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  54         ndr_print_uint16(ndr, "day", r->day);
  55         ndr_print_uint16(ndr, "hour", r->hour);
  56         ndr_print_uint16(ndr, "minute", r->minute);
  57         ndr_print_uint16(ndr, "second", r->second);
  58         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  59         ndr->depth--;
  60 }
  61
  62 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  63 {
  64         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  65 }
  66
  67 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  68 {
  69         if (ndr_flags & NDR_SCALARS) {
  70                 NDR_CHECK(ndr_push_align(ndr, 5));
  71                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  72                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  73                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  74         }
  75         if (ndr_flags & NDR_BUFFERS) {
  76                 if (r->time) {
  77                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  78                 }
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  84 {
  85         uint32_t _ptr_time;
  86         TALLOC_CTX *_mem_save_time_0;
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_pull_align(ndr, 5));
  89                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  90                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  91                 if (_ptr_time) {
  92                         NDR_PULL_ALLOC(ndr, r->time);
  93                 } else {
  94                         r->time = NULL;
  95                 }
  96                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  97         }
  98         if (ndr_flags & NDR_BUFFERS) {
  99                 if (r->time) {
 100                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
 101                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
 102                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
 103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 110 {
 111         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 112         ndr->depth++;
 113         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 114         ndr_print_ptr(ndr, "time", r->time);
 115         ndr->depth++;
 116         if (r->time) {
 117                 ndr_print_spoolss_Time(ndr, "time", r->time);
 118         }
 119         ndr->depth--;
 120         ndr->depth--;
 121 }
 122
 123 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 124 {
 125         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 130 {
 131         uint16_t v;
 132         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 133         *r = v;
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 143                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 144                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 145         }
 146         ndr_print_enum(ndr, name, "ENUM", val, r);
 147 }
 148
 149 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 150 {
 151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 152         return NDR_ERR_SUCCESS;
 153 }
 154
 155 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 156 {
 157         uint32_t v;
 158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 159         *r = v;
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 164 {
 165         const char *val = NULL;
 166
 167         switch (r) {
 168                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 169                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 170                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 171                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 172                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 173         }
 174         ndr_print_enum(ndr, name, "ENUM", val, r);
 175 }
 176
 177 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 178 {
 179         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 184 {
 185         uint32_t v;
 186         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 187         *r = v;
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 192 {
 193         const char *val = NULL;
 194
 195         switch (r) {
 196                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 197                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 198                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 199         }
 200         ndr_print_enum(ndr, name, "ENUM", val, r);
 201 }
 202
 203 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 204 {
 205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 210 {
 211         uint32_t v;
 212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 213         *r = v;
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 218 {
 219         const char *val = NULL;
 220
 221         switch (r) {
 222                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 223                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 224                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 225                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 226                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 227         }
 228         ndr_print_enum(ndr, name, "ENUM", val, r);
 229 }
 230
 231 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 232 {
 233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 238 {
 239         uint32_t v;
 240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 241         *r = v;
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 246 {
 247         ndr_print_uint32(ndr, name, r);
 248         ndr->depth++;
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 274         ndr->depth--;
 275 }
 276
 277 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 278 {
 279         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 284 {
 285         uint32_t v;
 286         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 287         *r = v;
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 292 {
 293         ndr_print_uint32(ndr, name, r);
 294         ndr->depth++;
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 308         ndr->depth--;
 309 }
 310
 311 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 312 {
 313         if (ndr_flags & NDR_SCALARS) {
 314                 NDR_CHECK(ndr_push_align(ndr, 5));
 315                 {
 316                         uint32_t _flags_save_string = ndr->flags;
 317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 319                         ndr->flags = _flags_save_string;
 320                 }
 321                 {
 322                         uint32_t _flags_save_string = ndr->flags;
 323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 325                         ndr->flags = _flags_save_string;
 326                 }
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 330                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 340                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 342                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 346                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 349                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 354                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 355         }
 356         if (ndr_flags & NDR_BUFFERS) {
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 360                         if (r->printername) {
 361                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                         }
 364                         ndr->flags = _flags_save_string;
 365                 }
 366                 {
 367                         uint32_t _flags_save_string = ndr->flags;
 368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 369                         if (r->servername) {
 370                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 371                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 372                         }
 373                         ndr->flags = _flags_save_string;
 374                 }
 375         }
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 380 {
 381         uint32_t _ptr_printername;
 382         TALLOC_CTX *_mem_save_printername_0;
 383         uint32_t _ptr_servername;
 384         TALLOC_CTX *_mem_save_servername_0;
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_align(ndr, 5));
 387                 {
 388                         uint32_t _flags_save_string = ndr->flags;
 389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 391                         if (_ptr_printername) {
 392                                 NDR_PULL_ALLOC(ndr, r->printername);
 393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 394                         } else {
 395                                 r->printername = NULL;
 396                         }
 397                         ndr->flags = _flags_save_string;
 398                 }
 399                 {
 400                         uint32_t _flags_save_string = ndr->flags;
 401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 403                         if (_ptr_servername) {
 404                                 NDR_PULL_ALLOC(ndr, r->servername);
 405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 406                         } else {
 407                                 r->servername = NULL;
 408                         }
 409                         ndr->flags = _flags_save_string;
 410                 }
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 414                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 424                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 426                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 429                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 430                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 433                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 434                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 439         }
 440         if (ndr_flags & NDR_BUFFERS) {
 441                 {
 442                         uint32_t _flags_save_string = ndr->flags;
 443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 444                         if (r->printername) {
 445                                 uint32_t _relative_save_offset;
 446                                 _relative_save_offset = ndr->offset;
 447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 448                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 449                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 452                                 if (ndr->offset > ndr->relative_highest_offset) {
 453                                         ndr->relative_highest_offset = ndr->offset;
 454                                 }
 455                                 ndr->offset = _relative_save_offset;
 456                         }
 457                         ndr->flags = _flags_save_string;
 458                 }
 459                 {
 460                         uint32_t _flags_save_string = ndr->flags;
 461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 462                         if (r->servername) {
 463                                 uint32_t _relative_save_offset;
 464                                 _relative_save_offset = ndr->offset;
 465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 466                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 467                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 470                                 if (ndr->offset > ndr->relative_highest_offset) {
 471                                         ndr->relative_highest_offset = ndr->offset;
 472                                 }
 473                                 ndr->offset = _relative_save_offset;
 474                         }
 475                         ndr->flags = _flags_save_string;
 476                 }
 477         }
 478         return NDR_ERR_SUCCESS;
 479 }
 480
 481 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 482 {
 483         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 484         ndr->depth++;
 485         ndr_print_ptr(ndr, "printername", r->printername);
 486         ndr->depth++;
 487         if (r->printername) {
 488                 ndr_print_string(ndr, "printername", r->printername);
 489         }
 490         ndr->depth--;
 491         ndr_print_ptr(ndr, "servername", r->servername);
 492         ndr->depth++;
 493         if (r->servername) {
 494                 ndr_print_string(ndr, "servername", r->servername);
 495         }
 496         ndr->depth--;
 497         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 498         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 499         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 500         ndr_print_spoolss_Time(ndr, "time", &r->time);
 501         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 502         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 503         ndr_print_uint32(ndr, "version", r->version);
 504         ndr_print_uint32(ndr, "free_build", r->free_build);
 505         ndr_print_uint32(ndr, "spooling", r->spooling);
 506         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 507         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 508         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 509         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 510         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 511         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 512         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 513         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 514         ndr_print_uint32(ndr, "change_id", r->change_id);
 515         ndr_print_WERROR(ndr, "last_error", r->last_error);
 516         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 517         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 518         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 519         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 520         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 521         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 522         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 523         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 524         ndr->depth--;
 525 }
 526
 527 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 528 {
 529         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 530 }
 531
 532 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 533 {
 534         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 535         return NDR_ERR_SUCCESS;
 536 }
 537
 538 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 539 {
 540         uint32_t v;
 541         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 542         *r = v;
 543         return NDR_ERR_SUCCESS;
 544 }
 545
 546 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 547 {
 548         ndr_print_uint32(ndr, name, r);
 549         ndr->depth++;
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 578         ndr->depth--;
 579 }
 580
 581 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 582 {
 583         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 584         return NDR_ERR_SUCCESS;
 585 }
 586
 587 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 588 {
 589         uint16_t v;
 590         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 591         *r = v;
 592         return NDR_ERR_SUCCESS;
 593 }
 594
 595 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 596 {
 597         const char *val = NULL;
 598
 599         switch (r) {
 600                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 601                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 602                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 603         }
 604         ndr_print_enum(ndr, name, "ENUM", val, r);
 605 }
 606
 607 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 608 {
 609         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 610         return NDR_ERR_SUCCESS;
 611 }
 612
 613 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 614 {
 615         uint16_t v;
 616         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 617         *r = v;
 618         return NDR_ERR_SUCCESS;
 619 }
 620
 621 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 622 {
 623         const char *val = NULL;
 624
 625         switch (r) {
 626                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 627                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 628         }
 629         ndr_print_enum(ndr, name, "ENUM", val, r);
 630 }
 631
 632 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 633 {
 634         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 635         return NDR_ERR_SUCCESS;
 636 }
 637
 638 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 639 {
 640         uint16_t v;
 641         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 642         *r = v;
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 647 {
 648         const char *val = NULL;
 649
 650         switch (r) {
 651                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 652                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 653                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 654                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 655                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 656                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 657                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 658                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 659                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 660                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 661                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 662                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 663                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 664                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 665                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 666                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 667                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 668                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 669                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 670                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 671                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 672                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 673                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 674                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 675                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 676                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 677                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 678                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 679                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 680                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 681                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 682                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 683                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 684                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 685                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 686                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 687                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 688                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 689                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 690                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 691                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 692                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 693                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 694                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 695                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 696                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 697                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 698                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 699                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 700                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 701                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 702                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 703                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 704                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 705                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 706                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 707                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 708                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 709                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 710                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 711                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 712                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 713                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 714                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 715                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 716                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 717                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 718                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 719                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 720                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 721                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 722                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 723                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 724                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 725                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 726                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 727                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 728                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 729                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 730                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 731                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 732                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 733                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 734                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 735                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 736                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 737                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 738                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 739                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 740                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 741                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 742         }
 743         ndr_print_enum(ndr, name, "ENUM", val, r);
 744 }
 745
 746 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 747 {
 748         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 749         return NDR_ERR_SUCCESS;
 750 }
 751
 752 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 753 {
 754         uint16_t v;
 755         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 756         *r = v;
 757         return NDR_ERR_SUCCESS;
 758 }
 759
 760 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 761 {
 762         const char *val = NULL;
 763
 764         switch (r) {
 765                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 766                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 767                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 768                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 769                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 770                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 771                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 772                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 773                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 774                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 775                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 776                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 777                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 778         }
 779         ndr_print_enum(ndr, name, "ENUM", val, r);
 780 }
 781
 782 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 783 {
 784         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 785         return NDR_ERR_SUCCESS;
 786 }
 787
 788 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 789 {
 790         uint16_t v;
 791         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 792         *r = v;
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 797 {
 798         const char *val = NULL;
 799
 800         switch (r) {
 801                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 802                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 803                 case DMRES_LOW: val = "DMRES_LOW"; break;
 804                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 805         }
 806         ndr_print_enum(ndr, name, "ENUM", val, r);
 807 }
 808
 809 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 810 {
 811         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 812         return NDR_ERR_SUCCESS;
 813 }
 814
 815 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 816 {
 817         uint16_t v;
 818         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 819         *r = v;
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 824 {
 825         const char *val = NULL;
 826
 827         switch (r) {
 828                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 829                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 830         }
 831         ndr_print_enum(ndr, name, "ENUM", val, r);
 832 }
 833
 834 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 835 {
 836         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 837         return NDR_ERR_SUCCESS;
 838 }
 839
 840 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 841 {
 842         uint16_t v;
 843         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 844         *r = v;
 845         return NDR_ERR_SUCCESS;
 846 }
 847
 848 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 849 {
 850         const char *val = NULL;
 851
 852         switch (r) {
 853                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 854                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 855                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 856         }
 857         ndr_print_enum(ndr, name, "ENUM", val, r);
 858 }
 859
 860 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 861 {
 862         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 863         return NDR_ERR_SUCCESS;
 864 }
 865
 866 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 867 {
 868         uint16_t v;
 869         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 870         *r = v;
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 875 {
 876         const char *val = NULL;
 877
 878         switch (r) {
 879                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 880                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 881                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 882                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 883         }
 884         ndr_print_enum(ndr, name, "ENUM", val, r);
 885 }
 886
 887 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 888 {
 889         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 890         return NDR_ERR_SUCCESS;
 891 }
 892
 893 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 894 {
 895         uint16_t v;
 896         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 897         *r = v;
 898         return NDR_ERR_SUCCESS;
 899 }
 900
 901 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 902 {
 903         const char *val = NULL;
 904
 905         switch (r) {
 906                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 907                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 908         }
 909         ndr_print_enum(ndr, name, "ENUM", val, r);
 910 }
 911
 912 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 913 {
 914         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 915         return NDR_ERR_SUCCESS;
 916 }
 917
 918 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 919 {
 920         uint32_t v;
 921         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 922         *r = v;
 923         return NDR_ERR_SUCCESS;
 924 }
 925
 926 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 927 {
 928         const char *val = NULL;
 929
 930         switch (r) {
 931                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 932                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 933         }
 934         ndr_print_enum(ndr, name, "ENUM", val, r);
 935 }
 936
 937 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 938 {
 939         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 940         return NDR_ERR_SUCCESS;
 941 }
 942
 943 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 944 {
 945         uint32_t v;
 946         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 947         *r = v;
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 952 {
 953         const char *val = NULL;
 954
 955         switch (r) {
 956                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 957                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 958                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 959                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 960         }
 961         ndr_print_enum(ndr, name, "ENUM", val, r);
 962 }
 963
 964 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 965 {
 966         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 967         return NDR_ERR_SUCCESS;
 968 }
 969
 970 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 971 {
 972         uint32_t v;
 973         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 974         *r = v;
 975         return NDR_ERR_SUCCESS;
 976 }
 977
 978 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 979 {
 980         const char *val = NULL;
 981
 982         switch (r) {
 983                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 984                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 985                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 986                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 987         }
 988         ndr_print_enum(ndr, name, "ENUM", val, r);
 989 }
 990
 991 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 992 {
 993         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 994         return NDR_ERR_SUCCESS;
 995 }
 996
 997 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 998 {
 999         uint32_t v;
1000         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1001         *r = v;
1002         return NDR_ERR_SUCCESS;
1003 }
1004
1005 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1006 {
1007         const char *val = NULL;
1008
1009         switch (r) {
1010                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1011                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1012                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1013         }
1014         ndr_print_enum(ndr, name, "ENUM", val, r);
1015 }
1016
1017 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1018 {
1019         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1020         return NDR_ERR_SUCCESS;
1021 }
1022
1023 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1024 {
1025         uint32_t v;
1026         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1027         *r = v;
1028         return NDR_ERR_SUCCESS;
1029 }
1030
1031 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1032 {
1033         const char *val = NULL;
1034
1035         switch (r) {
1036                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1037                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1038                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1039                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1040                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1041                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1042                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1043                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1044                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1045                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1046         }
1047         ndr_print_enum(ndr, name, "ENUM", val, r);
1048 }
1049
1050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1051 {
1052         if (ndr_flags & NDR_SCALARS) {
1053                 NDR_CHECK(ndr_push_align(ndr, 4));
1054                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1055                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1056                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1057                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1059                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1060                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1062                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1063                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1066                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1067                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1070                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1072                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1073                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1074                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1078                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1080                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1081                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1082                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1083                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1088                 {
1089                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1091                         {
1092                                 struct ndr_push *_ndr_driverextra_data;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1094                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1096                         }
1097                         ndr->flags = _flags_save_DATA_BLOB;
1098                 }
1099                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1100         }
1101         if (ndr_flags & NDR_BUFFERS) {
1102         }
1103         return NDR_ERR_SUCCESS;
1104 }
1105
1106 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1107 {
1108         if (ndr_flags & NDR_SCALARS) {
1109                 NDR_CHECK(ndr_pull_align(ndr, 4));
1110                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1112                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1113                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1115                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1116                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1118                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1119                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1122                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1123                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1126                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1127                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1128                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1129                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1130                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1134                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1136                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1137                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1138                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1139                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1144                 {
1145                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1147                         {
1148                                 struct ndr_pull *_ndr_driverextra_data;
1149                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1150                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1151                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1152                         }
1153                         ndr->flags = _flags_save_DATA_BLOB;
1154                 }
1155                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1156         }
1157         if (ndr_flags & NDR_BUFFERS) {
1158         }
1159         return NDR_ERR_SUCCESS;
1160 }
1161
1162 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1163 {
1164         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1165         ndr->depth++;
1166         ndr_print_string(ndr, "devicename", r->devicename);
1167         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1168         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1169         ndr_print_uint16(ndr, "size", r->size);
1170         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1171         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1172         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1173         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1174         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1175         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1176         ndr_print_uint16(ndr, "scale", r->scale);
1177         ndr_print_uint16(ndr, "copies", r->copies);
1178         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1179         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1180         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1181         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1182         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1183         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1184         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1185         ndr_print_string(ndr, "formname", r->formname);
1186         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1187         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1188         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1189         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1190         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1191         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1192         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1193         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1194         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1195         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1196         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1197         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1198         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1199         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1200         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1201         ndr->depth--;
1202 }
1203
1204 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1205 {
1206         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1207 }
1208
1209 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1210 {
1211         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1212         return NDR_ERR_SUCCESS;
1213 }
1214
1215 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1216 {
1217         uint32_t v;
1218         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1219         *r = v;
1220         return NDR_ERR_SUCCESS;
1221 }
1222
1223 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1224 {
1225         ndr_print_uint32(ndr, name, r);
1226         ndr->depth++;
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1246         ndr->depth--;
1247 }
1248
1249 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1250 {
1251         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1252         return NDR_ERR_SUCCESS;
1253 }
1254
1255 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1256 {
1257         uint32_t v;
1258         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1259         *r = v;
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1264 {
1265         ndr_print_uint32(ndr, name, r);
1266         ndr->depth++;
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1283         ndr->depth--;
1284 }
1285
1286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1287 {
1288         if (ndr_flags & NDR_SCALARS) {
1289                 NDR_CHECK(ndr_push_align(ndr, 5));
1290                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1291                 {
1292                         uint32_t _flags_save_string = ndr->flags;
1293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1295                         ndr->flags = _flags_save_string;
1296                 }
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1301                         ndr->flags = _flags_save_string;
1302                 }
1303                 {
1304                         uint32_t _flags_save_string = ndr->flags;
1305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1307                         ndr->flags = _flags_save_string;
1308                 }
1309                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1310         }
1311         if (ndr_flags & NDR_BUFFERS) {
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         if (r->description) {
1316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
1317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1318                         }
1319                         ndr->flags = _flags_save_string;
1320                 }
1321                 {
1322                         uint32_t _flags_save_string = ndr->flags;
1323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1324                         if (r->name) {
1325                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
1326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1327                         }
1328                         ndr->flags = _flags_save_string;
1329                 }
1330                 {
1331                         uint32_t _flags_save_string = ndr->flags;
1332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1333                         if (r->comment) {
1334                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1335                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1336                         }
1337                         ndr->flags = _flags_save_string;
1338                 }
1339         }
1340         return NDR_ERR_SUCCESS;
1341 }
1342
1343 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1344 {
1345         uint32_t _ptr_description;
1346         TALLOC_CTX *_mem_save_description_0;
1347         uint32_t _ptr_name;
1348         TALLOC_CTX *_mem_save_name_0;
1349         uint32_t _ptr_comment;
1350         TALLOC_CTX *_mem_save_comment_0;
1351         if (ndr_flags & NDR_SCALARS) {
1352                 NDR_CHECK(ndr_pull_align(ndr, 5));
1353                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1354                 {
1355                         uint32_t _flags_save_string = ndr->flags;
1356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1357                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1358                         if (_ptr_description) {
1359                                 NDR_PULL_ALLOC(ndr, r->description);
1360                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1361                         } else {
1362                                 r->description = NULL;
1363                         }
1364                         ndr->flags = _flags_save_string;
1365                 }
1366                 {
1367                         uint32_t _flags_save_string = ndr->flags;
1368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1369                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1370                         if (_ptr_name) {
1371                                 NDR_PULL_ALLOC(ndr, r->name);
1372                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1373                         } else {
1374                                 r->name = NULL;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1382                         if (_ptr_comment) {
1383                                 NDR_PULL_ALLOC(ndr, r->comment);
1384                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1385                         } else {
1386                                 r->comment = NULL;
1387                         }
1388                         ndr->flags = _flags_save_string;
1389                 }
1390                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1391         }
1392         if (ndr_flags & NDR_BUFFERS) {
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->description) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1400                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1404                                 if (ndr->offset > ndr->relative_highest_offset) {
1405                                         ndr->relative_highest_offset = ndr->offset;
1406                                 }
1407                                 ndr->offset = _relative_save_offset;
1408                         }
1409                         ndr->flags = _flags_save_string;
1410                 }
1411                 {
1412                         uint32_t _flags_save_string = ndr->flags;
1413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1414                         if (r->name) {
1415                                 uint32_t _relative_save_offset;
1416                                 _relative_save_offset = ndr->offset;
1417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1418                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1419                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1422                                 if (ndr->offset > ndr->relative_highest_offset) {
1423                                         ndr->relative_highest_offset = ndr->offset;
1424                                 }
1425                                 ndr->offset = _relative_save_offset;
1426                         }
1427                         ndr->flags = _flags_save_string;
1428                 }
1429                 {
1430                         uint32_t _flags_save_string = ndr->flags;
1431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1432                         if (r->comment) {
1433                                 uint32_t _relative_save_offset;
1434                                 _relative_save_offset = ndr->offset;
1435                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1436                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1437                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1438                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1439                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1440                                 if (ndr->offset > ndr->relative_highest_offset) {
1441                                         ndr->relative_highest_offset = ndr->offset;
1442                                 }
1443                                 ndr->offset = _relative_save_offset;
1444                         }
1445                         ndr->flags = _flags_save_string;
1446                 }
1447         }
1448         return NDR_ERR_SUCCESS;
1449 }
1450
1451 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1452 {
1453         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1454         ndr->depth++;
1455         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1456         ndr_print_ptr(ndr, "description", r->description);
1457         ndr->depth++;
1458         if (r->description) {
1459                 ndr_print_string(ndr, "description", r->description);
1460         }
1461         ndr->depth--;
1462         ndr_print_ptr(ndr, "name", r->name);
1463         ndr->depth++;
1464         if (r->name) {
1465                 ndr_print_string(ndr, "name", r->name);
1466         }
1467         ndr->depth--;
1468         ndr_print_ptr(ndr, "comment", r->comment);
1469         ndr->depth++;
1470         if (r->comment) {
1471                 ndr_print_string(ndr, "comment", r->comment);
1472         }
1473         ndr->depth--;
1474         ndr->depth--;
1475 }
1476
1477 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1478 {
1479         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1480 }
1481
1482 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1483 {
1484         if (ndr_flags & NDR_SCALARS) {
1485                 NDR_CHECK(ndr_push_align(ndr, 5));
1486                 {
1487                         uint32_t _flags_save_string = ndr->flags;
1488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1490                         ndr->flags = _flags_save_string;
1491                 }
1492                 {
1493                         uint32_t _flags_save_string = ndr->flags;
1494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1502                         ndr->flags = _flags_save_string;
1503                 }
1504                 {
1505                         uint32_t _flags_save_string = ndr->flags;
1506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1508                         ndr->flags = _flags_save_string;
1509                 }
1510                 {
1511                         uint32_t _flags_save_string = ndr->flags;
1512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1514                         ndr->flags = _flags_save_string;
1515                 }
1516                 {
1517                         uint32_t _flags_save_string = ndr->flags;
1518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1520                         ndr->flags = _flags_save_string;
1521                 }
1522                 {
1523                         uint32_t _flags_save_string = ndr->flags;
1524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1526                         ndr->flags = _flags_save_string;
1527                 }
1528                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1529                 {
1530                         uint32_t _flags_save_string = ndr->flags;
1531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1533                         ndr->flags = _flags_save_string;
1534                 }
1535                 {
1536                         uint32_t _flags_save_string = ndr->flags;
1537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1539                         ndr->flags = _flags_save_string;
1540                 }
1541                 {
1542                         uint32_t _flags_save_string = ndr->flags;
1543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 {
1548                         uint32_t _flags_save_string = ndr->flags;
1549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1551                         ndr->flags = _flags_save_string;
1552                 }
1553                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1554                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1559                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1562                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1563         }
1564         if (ndr_flags & NDR_BUFFERS) {
1565                 {
1566                         uint32_t _flags_save_string = ndr->flags;
1567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1568                         if (r->servername) {
1569                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1570                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1571                         }
1572                         ndr->flags = _flags_save_string;
1573                 }
1574                 {
1575                         uint32_t _flags_save_string = ndr->flags;
1576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1577                         if (r->printername) {
1578                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1580                         }
1581                         ndr->flags = _flags_save_string;
1582                 }
1583                 {
1584                         uint32_t _flags_save_string = ndr->flags;
1585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1586                         if (r->sharename) {
1587                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1589                         }
1590                         ndr->flags = _flags_save_string;
1591                 }
1592                 {
1593                         uint32_t _flags_save_string = ndr->flags;
1594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1595                         if (r->portname) {
1596                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1597                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1598                         }
1599                         ndr->flags = _flags_save_string;
1600                 }
1601                 {
1602                         uint32_t _flags_save_string = ndr->flags;
1603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1604                         if (r->drivername) {
1605                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1606                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1607                         }
1608                         ndr->flags = _flags_save_string;
1609                 }
1610                 {
1611                         uint32_t _flags_save_string = ndr->flags;
1612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1613                         if (r->comment) {
1614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1616                         }
1617                         ndr->flags = _flags_save_string;
1618                 }
1619                 {
1620                         uint32_t _flags_save_string = ndr->flags;
1621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1622                         if (r->location) {
1623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1625                         }
1626                         ndr->flags = _flags_save_string;
1627                 }
1628                 if (r->devmode) {
1629                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1630                         {
1631                                 struct ndr_push *_ndr_devmode;
1632                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1633                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1634                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1635                         }
1636                 }
1637                 {
1638                         uint32_t _flags_save_string = ndr->flags;
1639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1640                         if (r->sepfile) {
1641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1643                         }
1644                         ndr->flags = _flags_save_string;
1645                 }
1646                 {
1647                         uint32_t _flags_save_string = ndr->flags;
1648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1649                         if (r->printprocessor) {
1650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1652                         }
1653                         ndr->flags = _flags_save_string;
1654                 }
1655                 {
1656                         uint32_t _flags_save_string = ndr->flags;
1657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1658                         if (r->datatype) {
1659                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1661                         }
1662                         ndr->flags = _flags_save_string;
1663                 }
1664                 {
1665                         uint32_t _flags_save_string = ndr->flags;
1666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1667                         if (r->parameters) {
1668                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1669                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1670                         }
1671                         ndr->flags = _flags_save_string;
1672                 }
1673                 if (r->secdesc) {
1674                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1675                         {
1676                                 struct ndr_push *_ndr_secdesc;
1677                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1678                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1679                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1680                         }
1681                 }
1682         }
1683         return NDR_ERR_SUCCESS;
1684 }
1685
1686 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1687 {
1688         uint32_t _ptr_servername;
1689         TALLOC_CTX *_mem_save_servername_0;
1690         uint32_t _ptr_printername;
1691         TALLOC_CTX *_mem_save_printername_0;
1692         uint32_t _ptr_sharename;
1693         TALLOC_CTX *_mem_save_sharename_0;
1694         uint32_t _ptr_portname;
1695         TALLOC_CTX *_mem_save_portname_0;
1696         uint32_t _ptr_drivername;
1697         TALLOC_CTX *_mem_save_drivername_0;
1698         uint32_t _ptr_comment;
1699         TALLOC_CTX *_mem_save_comment_0;
1700         uint32_t _ptr_location;
1701         TALLOC_CTX *_mem_save_location_0;
1702         uint32_t _ptr_devmode;
1703         TALLOC_CTX *_mem_save_devmode_0;
1704         uint32_t _ptr_sepfile;
1705         TALLOC_CTX *_mem_save_sepfile_0;
1706         uint32_t _ptr_printprocessor;
1707         TALLOC_CTX *_mem_save_printprocessor_0;
1708         uint32_t _ptr_datatype;
1709         TALLOC_CTX *_mem_save_datatype_0;
1710         uint32_t _ptr_parameters;
1711         TALLOC_CTX *_mem_save_parameters_0;
1712         uint32_t _ptr_secdesc;
1713         TALLOC_CTX *_mem_save_secdesc_0;
1714         if (ndr_flags & NDR_SCALARS) {
1715                 NDR_CHECK(ndr_pull_align(ndr, 5));
1716                 {
1717                         uint32_t _flags_save_string = ndr->flags;
1718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1720                         if (_ptr_servername) {
1721                                 NDR_PULL_ALLOC(ndr, r->servername);
1722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1723                         } else {
1724                                 r->servername = NULL;
1725                         }
1726                         ndr->flags = _flags_save_string;
1727                 }
1728                 {
1729                         uint32_t _flags_save_string = ndr->flags;
1730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1732                         if (_ptr_printername) {
1733                                 NDR_PULL_ALLOC(ndr, r->printername);
1734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1735                         } else {
1736                                 r->printername = NULL;
1737                         }
1738                         ndr->flags = _flags_save_string;
1739                 }
1740                 {
1741                         uint32_t _flags_save_string = ndr->flags;
1742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1744                         if (_ptr_sharename) {
1745                                 NDR_PULL_ALLOC(ndr, r->sharename);
1746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1747                         } else {
1748                                 r->sharename = NULL;
1749                         }
1750                         ndr->flags = _flags_save_string;
1751                 }
1752                 {
1753                         uint32_t _flags_save_string = ndr->flags;
1754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1756                         if (_ptr_portname) {
1757                                 NDR_PULL_ALLOC(ndr, r->portname);
1758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1759                         } else {
1760                                 r->portname = NULL;
1761                         }
1762                         ndr->flags = _flags_save_string;
1763                 }
1764                 {
1765                         uint32_t _flags_save_string = ndr->flags;
1766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1768                         if (_ptr_drivername) {
1769                                 NDR_PULL_ALLOC(ndr, r->drivername);
1770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1771                         } else {
1772                                 r->drivername = NULL;
1773                         }
1774                         ndr->flags = _flags_save_string;
1775                 }
1776                 {
1777                         uint32_t _flags_save_string = ndr->flags;
1778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1780                         if (_ptr_comment) {
1781                                 NDR_PULL_ALLOC(ndr, r->comment);
1782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1783                         } else {
1784                                 r->comment = NULL;
1785                         }
1786                         ndr->flags = _flags_save_string;
1787                 }
1788                 {
1789                         uint32_t _flags_save_string = ndr->flags;
1790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1792                         if (_ptr_location) {
1793                                 NDR_PULL_ALLOC(ndr, r->location);
1794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1795                         } else {
1796                                 r->location = NULL;
1797                         }
1798                         ndr->flags = _flags_save_string;
1799                 }
1800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1801                 if (_ptr_devmode) {
1802                         NDR_PULL_ALLOC(ndr, r->devmode);
1803                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1804                 } else {
1805                         r->devmode = NULL;
1806                 }
1807                 {
1808                         uint32_t _flags_save_string = ndr->flags;
1809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1811                         if (_ptr_sepfile) {
1812                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1814                         } else {
1815                                 r->sepfile = NULL;
1816                         }
1817                         ndr->flags = _flags_save_string;
1818                 }
1819                 {
1820                         uint32_t _flags_save_string = ndr->flags;
1821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1822                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1823                         if (_ptr_printprocessor) {
1824                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1825                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1826                         } else {
1827                                 r->printprocessor = NULL;
1828                         }
1829                         ndr->flags = _flags_save_string;
1830                 }
1831                 {
1832                         uint32_t _flags_save_string = ndr->flags;
1833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1834                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1835                         if (_ptr_datatype) {
1836                                 NDR_PULL_ALLOC(ndr, r->datatype);
1837                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1838                         } else {
1839                                 r->datatype = NULL;
1840                         }
1841                         ndr->flags = _flags_save_string;
1842                 }
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1847                         if (_ptr_parameters) {
1848                                 NDR_PULL_ALLOC(ndr, r->parameters);
1849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1850                         } else {
1851                                 r->parameters = NULL;
1852                         }
1853                         ndr->flags = _flags_save_string;
1854                 }
1855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1856                 if (_ptr_secdesc) {
1857                         NDR_PULL_ALLOC(ndr, r->secdesc);
1858                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1859                 } else {
1860                         r->secdesc = NULL;
1861                 }
1862                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1864                 if (r->priority > 99) {
1865                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1866                 }
1867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1870                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1873                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1874         }
1875         if (ndr_flags & NDR_BUFFERS) {
1876                 {
1877                         uint32_t _flags_save_string = ndr->flags;
1878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1879                         if (r->servername) {
1880                                 uint32_t _relative_save_offset;
1881                                 _relative_save_offset = ndr->offset;
1882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1883                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1884                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1887                                 if (ndr->offset > ndr->relative_highest_offset) {
1888                                         ndr->relative_highest_offset = ndr->offset;
1889                                 }
1890                                 ndr->offset = _relative_save_offset;
1891                         }
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         if (r->printername) {
1898                                 uint32_t _relative_save_offset;
1899                                 _relative_save_offset = ndr->offset;
1900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1901                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1902                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1905                                 if (ndr->offset > ndr->relative_highest_offset) {
1906                                         ndr->relative_highest_offset = ndr->offset;
1907                                 }
1908                                 ndr->offset = _relative_save_offset;
1909                         }
1910                         ndr->flags = _flags_save_string;
1911                 }
1912                 {
1913                         uint32_t _flags_save_string = ndr->flags;
1914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1915                         if (r->sharename) {
1916                                 uint32_t _relative_save_offset;
1917                                 _relative_save_offset = ndr->offset;
1918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1919                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1920                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1923                                 if (ndr->offset > ndr->relative_highest_offset) {
1924                                         ndr->relative_highest_offset = ndr->offset;
1925                                 }
1926                                 ndr->offset = _relative_save_offset;
1927                         }
1928                         ndr->flags = _flags_save_string;
1929                 }
1930                 {
1931                         uint32_t _flags_save_string = ndr->flags;
1932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1933                         if (r->portname) {
1934                                 uint32_t _relative_save_offset;
1935                                 _relative_save_offset = ndr->offset;
1936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1937                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1938                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1941                                 if (ndr->offset > ndr->relative_highest_offset) {
1942                                         ndr->relative_highest_offset = ndr->offset;
1943                                 }
1944                                 ndr->offset = _relative_save_offset;
1945                         }
1946                         ndr->flags = _flags_save_string;
1947                 }
1948                 {
1949                         uint32_t _flags_save_string = ndr->flags;
1950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1951                         if (r->drivername) {
1952                                 uint32_t _relative_save_offset;
1953                                 _relative_save_offset = ndr->offset;
1954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1955                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1956                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1959                                 if (ndr->offset > ndr->relative_highest_offset) {
1960                                         ndr->relative_highest_offset = ndr->offset;
1961                                 }
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966                 {
1967                         uint32_t _flags_save_string = ndr->flags;
1968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1969                         if (r->comment) {
1970                                 uint32_t _relative_save_offset;
1971                                 _relative_save_offset = ndr->offset;
1972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1973                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1974                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1977                                 if (ndr->offset > ndr->relative_highest_offset) {
1978                                         ndr->relative_highest_offset = ndr->offset;
1979                                 }
1980                                 ndr->offset = _relative_save_offset;
1981                         }
1982                         ndr->flags = _flags_save_string;
1983                 }
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->location) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1991                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1995                                 if (ndr->offset > ndr->relative_highest_offset) {
1996                                         ndr->relative_highest_offset = ndr->offset;
1997                                 }
1998                                 ndr->offset = _relative_save_offset;
1999                         }
2000                         ndr->flags = _flags_save_string;
2001                 }
2002                 if (r->devmode) {
2003                         uint32_t _relative_save_offset;
2004                         _relative_save_offset = ndr->offset;
2005                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2006                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2007                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2008                         {
2009                                 struct ndr_pull *_ndr_devmode;
2010                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2011                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2012                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2013                         }
2014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2015                         if (ndr->offset > ndr->relative_highest_offset) {
2016                                 ndr->relative_highest_offset = ndr->offset;
2017                         }
2018                         ndr->offset = _relative_save_offset;
2019                 }
2020                 {
2021                         uint32_t _flags_save_string = ndr->flags;
2022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2023                         if (r->sepfile) {
2024                                 uint32_t _relative_save_offset;
2025                                 _relative_save_offset = ndr->offset;
2026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
2027                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
2028                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
2029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
2030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
2031                                 if (ndr->offset > ndr->relative_highest_offset) {
2032                                         ndr->relative_highest_offset = ndr->offset;
2033                                 }
2034                                 ndr->offset = _relative_save_offset;
2035                         }
2036                         ndr->flags = _flags_save_string;
2037                 }
2038                 {
2039                         uint32_t _flags_save_string = ndr->flags;
2040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2041                         if (r->printprocessor) {
2042                                 uint32_t _relative_save_offset;
2043                                 _relative_save_offset = ndr->offset;
2044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2045                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2046                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2049                                 if (ndr->offset > ndr->relative_highest_offset) {
2050                                         ndr->relative_highest_offset = ndr->offset;
2051                                 }
2052                                 ndr->offset = _relative_save_offset;
2053                         }
2054                         ndr->flags = _flags_save_string;
2055                 }
2056                 {
2057                         uint32_t _flags_save_string = ndr->flags;
2058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2059                         if (r->datatype) {
2060                                 uint32_t _relative_save_offset;
2061                                 _relative_save_offset = ndr->offset;
2062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2063                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2064                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2067                                 if (ndr->offset > ndr->relative_highest_offset) {
2068                                         ndr->relative_highest_offset = ndr->offset;
2069                                 }
2070                                 ndr->offset = _relative_save_offset;
2071                         }
2072                         ndr->flags = _flags_save_string;
2073                 }
2074                 {
2075                         uint32_t _flags_save_string = ndr->flags;
2076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2077                         if (r->parameters) {
2078                                 uint32_t _relative_save_offset;
2079                                 _relative_save_offset = ndr->offset;
2080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2081                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2082                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2085                                 if (ndr->offset > ndr->relative_highest_offset) {
2086                                         ndr->relative_highest_offset = ndr->offset;
2087                                 }
2088                                 ndr->offset = _relative_save_offset;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 if (r->secdesc) {
2093                         uint32_t _relative_save_offset;
2094                         _relative_save_offset = ndr->offset;
2095                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2096                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2097                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2098                         {
2099                                 struct ndr_pull *_ndr_secdesc;
2100                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2101                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2102                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2103                         }
2104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2105                         if (ndr->offset > ndr->relative_highest_offset) {
2106                                 ndr->relative_highest_offset = ndr->offset;
2107                         }
2108                         ndr->offset = _relative_save_offset;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "servername", r->servername);
2119         ndr->depth++;
2120         if (r->servername) {
2121                 ndr_print_string(ndr, "servername", r->servername);
2122         }
2123         ndr->depth--;
2124         ndr_print_ptr(ndr, "printername", r->printername);
2125         ndr->depth++;
2126         if (r->printername) {
2127                 ndr_print_string(ndr, "printername", r->printername);
2128         }
2129         ndr->depth--;
2130         ndr_print_ptr(ndr, "sharename", r->sharename);
2131         ndr->depth++;
2132         if (r->sharename) {
2133                 ndr_print_string(ndr, "sharename", r->sharename);
2134         }
2135         ndr->depth--;
2136         ndr_print_ptr(ndr, "portname", r->portname);
2137         ndr->depth++;
2138         if (r->portname) {
2139                 ndr_print_string(ndr, "portname", r->portname);
2140         }
2141         ndr->depth--;
2142         ndr_print_ptr(ndr, "drivername", r->drivername);
2143         ndr->depth++;
2144         if (r->drivername) {
2145                 ndr_print_string(ndr, "drivername", r->drivername);
2146         }
2147         ndr->depth--;
2148         ndr_print_ptr(ndr, "comment", r->comment);
2149         ndr->depth++;
2150         if (r->comment) {
2151                 ndr_print_string(ndr, "comment", r->comment);
2152         }
2153         ndr->depth--;
2154         ndr_print_ptr(ndr, "location", r->location);
2155         ndr->depth++;
2156         if (r->location) {
2157                 ndr_print_string(ndr, "location", r->location);
2158         }
2159         ndr->depth--;
2160         ndr_print_ptr(ndr, "devmode", r->devmode);
2161         ndr->depth++;
2162         if (r->devmode) {
2163                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2164         }
2165         ndr->depth--;
2166         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2167         ndr->depth++;
2168         if (r->sepfile) {
2169                 ndr_print_string(ndr, "sepfile", r->sepfile);
2170         }
2171         ndr->depth--;
2172         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2173         ndr->depth++;
2174         if (r->printprocessor) {
2175                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2176         }
2177         ndr->depth--;
2178         ndr_print_ptr(ndr, "datatype", r->datatype);
2179         ndr->depth++;
2180         if (r->datatype) {
2181                 ndr_print_string(ndr, "datatype", r->datatype);
2182         }
2183         ndr->depth--;
2184         ndr_print_ptr(ndr, "parameters", r->parameters);
2185         ndr->depth++;
2186         if (r->parameters) {
2187                 ndr_print_string(ndr, "parameters", r->parameters);
2188         }
2189         ndr->depth--;
2190         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2191         ndr->depth++;
2192         if (r->secdesc) {
2193                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2194         }
2195         ndr->depth--;
2196         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2197         ndr_print_uint32(ndr, "priority", r->priority);
2198         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2199         ndr_print_uint32(ndr, "starttime", r->starttime);
2200         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2201         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2202         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2203         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2204         ndr->depth--;
2205 }
2206
2207 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2208 {
2209         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2210 }
2211
2212 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2213 {
2214         if (ndr_flags & NDR_SCALARS) {
2215                 NDR_CHECK(ndr_push_align(ndr, 5));
2216                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2217                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2218         }
2219         if (ndr_flags & NDR_BUFFERS) {
2220                 if (r->secdesc) {
2221                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
2222                         {
2223                                 struct ndr_push *_ndr_secdesc;
2224                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2225                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2226                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2227                         }
2228                 }
2229         }
2230         return NDR_ERR_SUCCESS;
2231 }
2232
2233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2234 {
2235         uint32_t _ptr_secdesc;
2236         TALLOC_CTX *_mem_save_secdesc_0;
2237         if (ndr_flags & NDR_SCALARS) {
2238                 NDR_CHECK(ndr_pull_align(ndr, 5));
2239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2240                 if (_ptr_secdesc) {
2241                         NDR_PULL_ALLOC(ndr, r->secdesc);
2242                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2243                 } else {
2244                         r->secdesc = NULL;
2245                 }
2246                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2247         }
2248         if (ndr_flags & NDR_BUFFERS) {
2249                 if (r->secdesc) {
2250                         uint32_t _relative_save_offset;
2251                         _relative_save_offset = ndr->offset;
2252                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2253                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2254                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2255                         {
2256                                 struct ndr_pull *_ndr_secdesc;
2257                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2258                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2259                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2260                         }
2261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2262                         if (ndr->offset > ndr->relative_highest_offset) {
2263                                 ndr->relative_highest_offset = ndr->offset;
2264                         }
2265                         ndr->offset = _relative_save_offset;
2266                 }
2267         }
2268         return NDR_ERR_SUCCESS;
2269 }
2270
2271 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2272 {
2273         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2274         ndr->depth++;
2275         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2276         ndr->depth++;
2277         if (r->secdesc) {
2278                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2279         }
2280         ndr->depth--;
2281         ndr->depth--;
2282 }
2283
2284 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2285 {
2286         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2287 }
2288
2289 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2290 {
2291         if (ndr_flags & NDR_SCALARS) {
2292                 NDR_CHECK(ndr_push_align(ndr, 5));
2293                 {
2294                         uint32_t _flags_save_string = ndr->flags;
2295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2297                         ndr->flags = _flags_save_string;
2298                 }
2299                 {
2300                         uint32_t _flags_save_string = ndr->flags;
2301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2303                         ndr->flags = _flags_save_string;
2304                 }
2305                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2306                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2307         }
2308         if (ndr_flags & NDR_BUFFERS) {
2309                 {
2310                         uint32_t _flags_save_string = ndr->flags;
2311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2312                         if (r->printername) {
2313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2315                         }
2316                         ndr->flags = _flags_save_string;
2317                 }
2318                 {
2319                         uint32_t _flags_save_string = ndr->flags;
2320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2321                         if (r->servername) {
2322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
2323                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2324                         }
2325                         ndr->flags = _flags_save_string;
2326                 }
2327         }
2328         return NDR_ERR_SUCCESS;
2329 }
2330
2331 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2332 {
2333         uint32_t _ptr_printername;
2334         TALLOC_CTX *_mem_save_printername_0;
2335         uint32_t _ptr_servername;
2336         TALLOC_CTX *_mem_save_servername_0;
2337         if (ndr_flags & NDR_SCALARS) {
2338                 NDR_CHECK(ndr_pull_align(ndr, 5));
2339                 {
2340                         uint32_t _flags_save_string = ndr->flags;
2341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2343                         if (_ptr_printername) {
2344                                 NDR_PULL_ALLOC(ndr, r->printername);
2345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2346                         } else {
2347                                 r->printername = NULL;
2348                         }
2349                         ndr->flags = _flags_save_string;
2350                 }
2351                 {
2352                         uint32_t _flags_save_string = ndr->flags;
2353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2355                         if (_ptr_servername) {
2356                                 NDR_PULL_ALLOC(ndr, r->servername);
2357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2358                         } else {
2359                                 r->servername = NULL;
2360                         }
2361                         ndr->flags = _flags_save_string;
2362                 }
2363                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2364                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2365         }
2366         if (ndr_flags & NDR_BUFFERS) {
2367                 {
2368                         uint32_t _flags_save_string = ndr->flags;
2369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2370                         if (r->printername) {
2371                                 uint32_t _relative_save_offset;
2372                                 _relative_save_offset = ndr->offset;
2373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2374                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2375                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2378                                 if (ndr->offset > ndr->relative_highest_offset) {
2379                                         ndr->relative_highest_offset = ndr->offset;
2380                                 }
2381                                 ndr->offset = _relative_save_offset;
2382                         }
2383                         ndr->flags = _flags_save_string;
2384                 }
2385                 {
2386                         uint32_t _flags_save_string = ndr->flags;
2387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2388                         if (r->servername) {
2389                                 uint32_t _relative_save_offset;
2390                                 _relative_save_offset = ndr->offset;
2391                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2392                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2393                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2394                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2395                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2396                                 if (ndr->offset > ndr->relative_highest_offset) {
2397                                         ndr->relative_highest_offset = ndr->offset;
2398                                 }
2399                                 ndr->offset = _relative_save_offset;
2400                         }
2401                         ndr->flags = _flags_save_string;
2402                 }
2403         }
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2408 {
2409         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2410         ndr->depth++;
2411         ndr_print_ptr(ndr, "printername", r->printername);
2412         ndr->depth++;
2413         if (r->printername) {
2414                 ndr_print_string(ndr, "printername", r->printername);
2415         }
2416         ndr->depth--;
2417         ndr_print_ptr(ndr, "servername", r->servername);
2418         ndr->depth++;
2419         if (r->servername) {
2420                 ndr_print_string(ndr, "servername", r->servername);
2421         }
2422         ndr->depth--;
2423         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2424         ndr->depth--;
2425 }
2426
2427 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2428 {
2429         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2430 }
2431
2432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2433 {
2434         if (ndr_flags & NDR_SCALARS) {
2435                 NDR_CHECK(ndr_push_align(ndr, 5));
2436                 {
2437                         uint32_t _flags_save_string = ndr->flags;
2438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2440                         ndr->flags = _flags_save_string;
2441                 }
2442                 {
2443                         uint32_t _flags_save_string = ndr->flags;
2444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2445                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2446                         ndr->flags = _flags_save_string;
2447                 }
2448                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2451                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2452         }
2453         if (ndr_flags & NDR_BUFFERS) {
2454                 {
2455                         uint32_t _flags_save_string = ndr->flags;
2456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2457                         if (r->printername) {
2458                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2459                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2460                         }
2461                         ndr->flags = _flags_save_string;
2462                 }
2463                 {
2464                         uint32_t _flags_save_string = ndr->flags;
2465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2466                         if (r->portname) {
2467                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
2468                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2469                         }
2470                         ndr->flags = _flags_save_string;
2471                 }
2472         }
2473         return NDR_ERR_SUCCESS;
2474 }
2475
2476 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2477 {
2478         uint32_t _ptr_printername;
2479         TALLOC_CTX *_mem_save_printername_0;
2480         uint32_t _ptr_portname;
2481         TALLOC_CTX *_mem_save_portname_0;
2482         if (ndr_flags & NDR_SCALARS) {
2483                 NDR_CHECK(ndr_pull_align(ndr, 5));
2484                 {
2485                         uint32_t _flags_save_string = ndr->flags;
2486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2487                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2488                         if (_ptr_printername) {
2489                                 NDR_PULL_ALLOC(ndr, r->printername);
2490                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2491                         } else {
2492                                 r->printername = NULL;
2493                         }
2494                         ndr->flags = _flags_save_string;
2495                 }
2496                 {
2497                         uint32_t _flags_save_string = ndr->flags;
2498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2499                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2500                         if (_ptr_portname) {
2501                                 NDR_PULL_ALLOC(ndr, r->portname);
2502                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2503                         } else {
2504                                 r->portname = NULL;
2505                         }
2506                         ndr->flags = _flags_save_string;
2507                 }
2508                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2512         }
2513         if (ndr_flags & NDR_BUFFERS) {
2514                 {
2515                         uint32_t _flags_save_string = ndr->flags;
2516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2517                         if (r->printername) {
2518                                 uint32_t _relative_save_offset;
2519                                 _relative_save_offset = ndr->offset;
2520                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2521                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2522                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2523                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2524                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2525                                 if (ndr->offset > ndr->relative_highest_offset) {
2526                                         ndr->relative_highest_offset = ndr->offset;
2527                                 }
2528                                 ndr->offset = _relative_save_offset;
2529                         }
2530                         ndr->flags = _flags_save_string;
2531                 }
2532                 {
2533                         uint32_t _flags_save_string = ndr->flags;
2534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2535                         if (r->portname) {
2536                                 uint32_t _relative_save_offset;
2537                                 _relative_save_offset = ndr->offset;
2538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2539                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2540                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2543                                 if (ndr->offset > ndr->relative_highest_offset) {
2544                                         ndr->relative_highest_offset = ndr->offset;
2545                                 }
2546                                 ndr->offset = _relative_save_offset;
2547                         }
2548                         ndr->flags = _flags_save_string;
2549                 }
2550         }
2551         return NDR_ERR_SUCCESS;
2552 }
2553
2554 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2555 {
2556         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2557         ndr->depth++;
2558         ndr_print_ptr(ndr, "printername", r->printername);
2559         ndr->depth++;
2560         if (r->printername) {
2561                 ndr_print_string(ndr, "printername", r->printername);
2562         }
2563         ndr->depth--;
2564         ndr_print_ptr(ndr, "portname", r->portname);
2565         ndr->depth++;
2566         if (r->portname) {
2567                 ndr_print_string(ndr, "portname", r->portname);
2568         }
2569         ndr->depth--;
2570         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2571         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2572         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2573         ndr->depth--;
2574 }
2575
2576 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2577 {
2578         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2579 }
2580
2581 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2582 {
2583         if (ndr_flags & NDR_SCALARS) {
2584                 NDR_CHECK(ndr_push_align(ndr, 4));
2585                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2586                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2587         }
2588         if (ndr_flags & NDR_BUFFERS) {
2589         }
2590         return NDR_ERR_SUCCESS;
2591 }
2592
2593 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2594 {
2595         if (ndr_flags & NDR_SCALARS) {
2596                 NDR_CHECK(ndr_pull_align(ndr, 4));
2597                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2598                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2599         }
2600         if (ndr_flags & NDR_BUFFERS) {
2601         }
2602         return NDR_ERR_SUCCESS;
2603 }
2604
2605 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2606 {
2607         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2608         ndr->depth++;
2609         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2610         ndr->depth--;
2611 }
2612
2613 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2614 {
2615         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2616 }
2617
2618 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2619 {
2620         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2621         return NDR_ERR_SUCCESS;
2622 }
2623
2624 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2625 {
2626         uint32_t v;
2627         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2628         *r = v;
2629         return NDR_ERR_SUCCESS;
2630 }
2631
2632 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2633 {
2634         ndr_print_uint32(ndr, name, r);
2635         ndr->depth++;
2636         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2637         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2638         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2639         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2640         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2641         ndr->depth--;
2642 }
2643
2644 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2645 {
2646         if (ndr_flags & NDR_SCALARS) {
2647                 NDR_CHECK(ndr_push_align(ndr, 5));
2648                 {
2649                         uint32_t _flags_save_string = ndr->flags;
2650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2652                         ndr->flags = _flags_save_string;
2653                 }
2654                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2655                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2656         }
2657         if (ndr_flags & NDR_BUFFERS) {
2658                 {
2659                         uint32_t _flags_save_string = ndr->flags;
2660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2661                         if (r->guid) {
2662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2664                         }
2665                         ndr->flags = _flags_save_string;
2666                 }
2667         }
2668         return NDR_ERR_SUCCESS;
2669 }
2670
2671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2672 {
2673         uint32_t _ptr_guid;
2674         TALLOC_CTX *_mem_save_guid_0;
2675         if (ndr_flags & NDR_SCALARS) {
2676                 NDR_CHECK(ndr_pull_align(ndr, 5));
2677                 {
2678                         uint32_t _flags_save_string = ndr->flags;
2679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2681                         if (_ptr_guid) {
2682                                 NDR_PULL_ALLOC(ndr, r->guid);
2683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2684                         } else {
2685                                 r->guid = NULL;
2686                         }
2687                         ndr->flags = _flags_save_string;
2688                 }
2689                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2690                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2691         }
2692         if (ndr_flags & NDR_BUFFERS) {
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         if (r->guid) {
2697                                 uint32_t _relative_save_offset;
2698                                 _relative_save_offset = ndr->offset;
2699                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2700                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2701                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2702                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2703                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2704                                 if (ndr->offset > ndr->relative_highest_offset) {
2705                                         ndr->relative_highest_offset = ndr->offset;
2706                                 }
2707                                 ndr->offset = _relative_save_offset;
2708                         }
2709                         ndr->flags = _flags_save_string;
2710                 }
2711         }
2712         return NDR_ERR_SUCCESS;
2713 }
2714
2715 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2716 {
2717         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2718         ndr->depth++;
2719         ndr_print_ptr(ndr, "guid", r->guid);
2720         ndr->depth++;
2721         if (r->guid) {
2722                 ndr_print_string(ndr, "guid", r->guid);
2723         }
2724         ndr->depth--;
2725         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2726         ndr->depth--;
2727 }
2728
2729 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2730 {
2731         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2732 }
2733
2734 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2735 {
2736         if (ndr_flags & NDR_SCALARS) {
2737                 NDR_CHECK(ndr_push_align(ndr, 5));
2738                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2739                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2740         }
2741         if (ndr_flags & NDR_BUFFERS) {
2742                 if (r->devmode) {
2743                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2744                         {
2745                                 struct ndr_push *_ndr_devmode;
2746                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2747                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2748                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2749                         }
2750                 }
2751         }
2752         return NDR_ERR_SUCCESS;
2753 }
2754
2755 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2756 {
2757         uint32_t _ptr_devmode;
2758         TALLOC_CTX *_mem_save_devmode_0;
2759         if (ndr_flags & NDR_SCALARS) {
2760                 NDR_CHECK(ndr_pull_align(ndr, 5));
2761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2762                 if (_ptr_devmode) {
2763                         NDR_PULL_ALLOC(ndr, r->devmode);
2764                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2765                 } else {
2766                         r->devmode = NULL;
2767                 }
2768                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2769         }
2770         if (ndr_flags & NDR_BUFFERS) {
2771                 if (r->devmode) {
2772                         uint32_t _relative_save_offset;
2773                         _relative_save_offset = ndr->offset;
2774                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2775                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2776                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2777                         {
2778                                 struct ndr_pull *_ndr_devmode;
2779                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2780                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2781                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2782                         }
2783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2784                         if (ndr->offset > ndr->relative_highest_offset) {
2785                                 ndr->relative_highest_offset = ndr->offset;
2786                         }
2787                         ndr->offset = _relative_save_offset;
2788                 }
2789         }
2790         return NDR_ERR_SUCCESS;
2791 }
2792
2793 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2794 {
2795         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2796         ndr->depth++;
2797         ndr_print_ptr(ndr, "devmode", r->devmode);
2798         ndr->depth++;
2799         if (r->devmode) {
2800                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2801         }
2802         ndr->depth--;
2803         ndr->depth--;
2804 }
2805
2806 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2807 {
2808         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2809         if (ndr_flags & NDR_SCALARS) {
2810                 int level = ndr_push_get_switch_value(ndr, r);
2811                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2812                 switch (level) {
2813                         case 0: {
2814                                 NDR_CHECK(ndr_push_align(ndr, 5));
2815                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2816                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2817                         break; }
2818
2819                         case 1: {
2820                                 NDR_CHECK(ndr_push_align(ndr, 5));
2821                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2822                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2823                         break; }
2824
2825                         case 2: {
2826                                 NDR_CHECK(ndr_push_align(ndr, 5));
2827                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2828                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2829                         break; }
2830
2831                         case 3: {
2832                                 NDR_CHECK(ndr_push_align(ndr, 5));
2833                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2834                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2835                         break; }
2836
2837                         case 4: {
2838                                 NDR_CHECK(ndr_push_align(ndr, 5));
2839                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2840                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2841                         break; }
2842
2843                         case 5: {
2844                                 NDR_CHECK(ndr_push_align(ndr, 5));
2845                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2846                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2847                         break; }
2848
2849                         case 6: {
2850                                 NDR_CHECK(ndr_push_align(ndr, 4));
2851                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2852                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2853                         break; }
2854
2855                         case 7: {
2856                                 NDR_CHECK(ndr_push_align(ndr, 5));
2857                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2858                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2859                         break; }
2860
2861                         case 8: {
2862                                 NDR_CHECK(ndr_push_align(ndr, 5));
2863                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2864                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2865                         break; }
2866
2867                         case 9: {
2868                                 NDR_CHECK(ndr_push_align(ndr, 5));
2869                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2870                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2871                         break; }
2872
2873                         default: {
2874                         break; }
2875
2876                 }
2877         }
2878         if (ndr_flags & NDR_BUFFERS) {
2879                 int level = ndr_push_get_switch_value(ndr, r);
2880                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2881                 switch (level) {
2882                         case 0:
2883                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2884                         break;
2885
2886                         case 1:
2887                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2888                         break;
2889
2890                         case 2:
2891                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2892                         break;
2893
2894                         case 3:
2895                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2896                         break;
2897
2898                         case 4:
2899                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2900                         break;
2901
2902                         case 5:
2903                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2904                         break;
2905
2906                         case 6:
2907                         break;
2908
2909                         case 7:
2910                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2911                         break;
2912
2913                         case 8:
2914                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2915                         break;
2916
2917                         case 9:
2918                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2919                         break;
2920
2921                         default:
2922                         break;
2923
2924                 }
2925         }
2926         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2927         return NDR_ERR_SUCCESS;
2928 }
2929
2930 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2931 {
2932         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2933         int level;
2934         level = ndr_pull_get_switch_value(ndr, r);
2935         if (ndr_flags & NDR_SCALARS) {
2936                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2937                 switch (level) {
2938                         case 0: {
2939                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2940                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2941                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2942                         break; }
2943
2944                         case 1: {
2945                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2946                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2947                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2948                         break; }
2949
2950                         case 2: {
2951                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2952                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2953                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2954                         break; }
2955
2956                         case 3: {
2957                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2958                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2959                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2960                         break; }
2961
2962                         case 4: {
2963                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2964                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2965                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2966                         break; }
2967
2968                         case 5: {
2969                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2970                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2971                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2972                         break; }
2973
2974                         case 6: {
2975                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2976                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2977                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2978                         break; }
2979
2980                         case 7: {
2981                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2982                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2983                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2984                         break; }
2985
2986                         case 8: {
2987                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2988                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2989                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2990                         break; }
2991
2992                         case 9: {
2993                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2994                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2995                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2996                         break; }
2997
2998                         default: {
2999                         break; }
3000
3001                 }
3002         }
3003         if (ndr_flags & NDR_BUFFERS) {
3004                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
3005                 switch (level) {
3006                         case 0:
3007                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3008                         break;
3009
3010                         case 1:
3011                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3012                         break;
3013
3014                         case 2:
3015                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3016                         break;
3017
3018                         case 3:
3019                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3020                         break;
3021
3022                         case 4:
3023                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3024                         break;
3025
3026                         case 5:
3027                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3028                         break;
3029
3030                         case 6:
3031                         break;
3032
3033                         case 7:
3034                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3035                         break;
3036
3037                         case 8:
3038                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3039                         break;
3040
3041                         case 9:
3042                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3043                         break;
3044
3045                         default:
3046                         break;
3047
3048                 }
3049         }
3050         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
3051         return NDR_ERR_SUCCESS;
3052 }
3053
3054 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
3055 {
3056         int level;
3057         level = ndr_print_get_switch_value(ndr, r);
3058         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
3059         switch (level) {
3060                 case 0:
3061                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
3062                 break;
3063
3064                 case 1:
3065                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
3066                 break;
3067
3068                 case 2:
3069                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
3070                 break;
3071
3072                 case 3:
3073                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
3074                 break;
3075
3076                 case 4:
3077                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3078                 break;
3079
3080                 case 5:
3081                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3082                 break;
3083
3084                 case 6:
3085                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3086                 break;
3087
3088                 case 7:
3089                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3090                 break;
3091
3092                 case 8:
3093                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3094                 break;
3095
3096                 case 9:
3097                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3098                 break;
3099
3100                 default:
3101                 break;
3102
3103         }
3104 }
3105
3106 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3107 {
3108         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3109 }
3110
3111 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3112 {
3113         if (ndr_flags & NDR_SCALARS) {
3114                 NDR_CHECK(ndr_push_align(ndr, 5));
3115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3117                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3118         }
3119         if (ndr_flags & NDR_BUFFERS) {
3120                 if (r->devmode) {
3121                         {
3122                                 struct ndr_push *_ndr_devmode;
3123                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3124                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3125                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3126                         }
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3133 {
3134         uint32_t _ptr_devmode;
3135         TALLOC_CTX *_mem_save_devmode_0;
3136         if (ndr_flags & NDR_SCALARS) {
3137                 NDR_CHECK(ndr_pull_align(ndr, 5));
3138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3140                 if (_ptr_devmode) {
3141                         NDR_PULL_ALLOC(ndr, r->devmode);
3142                 } else {
3143                         r->devmode = NULL;
3144                 }
3145                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3146         }
3147         if (ndr_flags & NDR_BUFFERS) {
3148                 if (r->devmode) {
3149                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3150                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3151                         {
3152                                 struct ndr_pull *_ndr_devmode;
3153                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3154                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3155                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3156                         }
3157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3158                 }
3159         }
3160         return NDR_ERR_SUCCESS;
3161 }
3162
3163 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3164 {
3165         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3166         ndr->depth++;
3167         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
3168         ndr_print_ptr(ndr, "devmode", r->devmode);
3169         ndr->depth++;
3170         if (r->devmode) {
3171                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3172         }
3173         ndr->depth--;
3174         ndr->depth--;
3175 }
3176
3177 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3178 {
3179         if (ndr_flags & NDR_SCALARS) {
3180                 NDR_CHECK(ndr_push_align(ndr, 5));
3181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3182                 {
3183                         uint32_t _flags_save_string = ndr->flags;
3184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3185                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3186                         ndr->flags = _flags_save_string;
3187                 }
3188                 {
3189                         uint32_t _flags_save_string = ndr->flags;
3190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3191                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3192                         ndr->flags = _flags_save_string;
3193                 }
3194                 {
3195                         uint32_t _flags_save_string = ndr->flags;
3196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3198                         ndr->flags = _flags_save_string;
3199                 }
3200                 {
3201                         uint32_t _flags_save_string = ndr->flags;
3202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3204                         ndr->flags = _flags_save_string;
3205                 }
3206                 {
3207                         uint32_t _flags_save_string = ndr->flags;
3208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3210                         ndr->flags = _flags_save_string;
3211                 }
3212                 {
3213                         uint32_t _flags_save_string = ndr->flags;
3214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3216                         ndr->flags = _flags_save_string;
3217                 }
3218                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3223                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3224                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3225         }
3226         if (ndr_flags & NDR_BUFFERS) {
3227                 {
3228                         uint32_t _flags_save_string = ndr->flags;
3229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3230                         if (r->printer_name) {
3231                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3232                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3233                         }
3234                         ndr->flags = _flags_save_string;
3235                 }
3236                 {
3237                         uint32_t _flags_save_string = ndr->flags;
3238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3239                         if (r->server_name) {
3240                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3241                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3242                         }
3243                         ndr->flags = _flags_save_string;
3244                 }
3245                 {
3246                         uint32_t _flags_save_string = ndr->flags;
3247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3248                         if (r->user_name) {
3249                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3250                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3251                         }
3252                         ndr->flags = _flags_save_string;
3253                 }
3254                 {
3255                         uint32_t _flags_save_string = ndr->flags;
3256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3257                         if (r->document_name) {
3258                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3259                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3260                         }
3261                         ndr->flags = _flags_save_string;
3262                 }
3263                 {
3264                         uint32_t _flags_save_string = ndr->flags;
3265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3266                         if (r->data_type) {
3267                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3268                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3269                         }
3270                         ndr->flags = _flags_save_string;
3271                 }
3272                 {
3273                         uint32_t _flags_save_string = ndr->flags;
3274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3275                         if (r->text_status) {
3276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3278                         }
3279                         ndr->flags = _flags_save_string;
3280                 }
3281         }
3282         return NDR_ERR_SUCCESS;
3283 }
3284
3285 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3286 {
3287         uint32_t _ptr_printer_name;
3288         TALLOC_CTX *_mem_save_printer_name_0;
3289         uint32_t _ptr_server_name;
3290         TALLOC_CTX *_mem_save_server_name_0;
3291         uint32_t _ptr_user_name;
3292         TALLOC_CTX *_mem_save_user_name_0;
3293         uint32_t _ptr_document_name;
3294         TALLOC_CTX *_mem_save_document_name_0;
3295         uint32_t _ptr_data_type;
3296         TALLOC_CTX *_mem_save_data_type_0;
3297         uint32_t _ptr_text_status;
3298         TALLOC_CTX *_mem_save_text_status_0;
3299         if (ndr_flags & NDR_SCALARS) {
3300                 NDR_CHECK(ndr_pull_align(ndr, 5));
3301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3302                 {
3303                         uint32_t _flags_save_string = ndr->flags;
3304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3306                         if (_ptr_printer_name) {
3307                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3309                         } else {
3310                                 r->printer_name = NULL;
3311                         }
3312                         ndr->flags = _flags_save_string;
3313                 }
3314                 {
3315                         uint32_t _flags_save_string = ndr->flags;
3316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3318                         if (_ptr_server_name) {
3319                                 NDR_PULL_ALLOC(ndr, r->server_name);
3320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3321                         } else {
3322                                 r->server_name = NULL;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3330                         if (_ptr_user_name) {
3331                                 NDR_PULL_ALLOC(ndr, r->user_name);
3332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3333                         } else {
3334                                 r->user_name = NULL;
3335                         }
3336                         ndr->flags = _flags_save_string;
3337                 }
3338                 {
3339                         uint32_t _flags_save_string = ndr->flags;
3340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3342                         if (_ptr_document_name) {
3343                                 NDR_PULL_ALLOC(ndr, r->document_name);
3344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3345                         } else {
3346                                 r->document_name = NULL;
3347                         }
3348                         ndr->flags = _flags_save_string;
3349                 }
3350                 {
3351                         uint32_t _flags_save_string = ndr->flags;
3352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3354                         if (_ptr_data_type) {
3355                                 NDR_PULL_ALLOC(ndr, r->data_type);
3356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3357                         } else {
3358                                 r->data_type = NULL;
3359                         }
3360                         ndr->flags = _flags_save_string;
3361                 }
3362                 {
3363                         uint32_t _flags_save_string = ndr->flags;
3364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3366                         if (_ptr_text_status) {
3367                                 NDR_PULL_ALLOC(ndr, r->text_status);
3368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3369                         } else {
3370                                 r->text_status = NULL;
3371                         }
3372                         ndr->flags = _flags_save_string;
3373                 }
3374                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3376                 if (r->priority > 99) {
3377                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3378                 }
3379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3382                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3383                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3384         }
3385         if (ndr_flags & NDR_BUFFERS) {
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->printer_name) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3393                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3397                                 if (ndr->offset > ndr->relative_highest_offset) {
3398                                         ndr->relative_highest_offset = ndr->offset;
3399                                 }
3400                                 ndr->offset = _relative_save_offset;
3401                         }
3402                         ndr->flags = _flags_save_string;
3403                 }
3404                 {
3405                         uint32_t _flags_save_string = ndr->flags;
3406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3407                         if (r->server_name) {
3408                                 uint32_t _relative_save_offset;
3409                                 _relative_save_offset = ndr->offset;
3410                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3411                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3412                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3413                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3414                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3415                                 if (ndr->offset > ndr->relative_highest_offset) {
3416                                         ndr->relative_highest_offset = ndr->offset;
3417                                 }
3418                                 ndr->offset = _relative_save_offset;
3419                         }
3420                         ndr->flags = _flags_save_string;
3421                 }
3422                 {
3423                         uint32_t _flags_save_string = ndr->flags;
3424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3425                         if (r->user_name) {
3426                                 uint32_t _relative_save_offset;
3427                                 _relative_save_offset = ndr->offset;
3428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3429                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3430                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3433                                 if (ndr->offset > ndr->relative_highest_offset) {
3434                                         ndr->relative_highest_offset = ndr->offset;
3435                                 }
3436                                 ndr->offset = _relative_save_offset;
3437                         }
3438                         ndr->flags = _flags_save_string;
3439                 }
3440                 {
3441                         uint32_t _flags_save_string = ndr->flags;
3442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3443                         if (r->document_name) {
3444                                 uint32_t _relative_save_offset;
3445                                 _relative_save_offset = ndr->offset;
3446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3447                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3448                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3451                                 if (ndr->offset > ndr->relative_highest_offset) {
3452                                         ndr->relative_highest_offset = ndr->offset;
3453                                 }
3454                                 ndr->offset = _relative_save_offset;
3455                         }
3456                         ndr->flags = _flags_save_string;
3457                 }
3458                 {
3459                         uint32_t _flags_save_string = ndr->flags;
3460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3461                         if (r->data_type) {
3462                                 uint32_t _relative_save_offset;
3463                                 _relative_save_offset = ndr->offset;
3464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3465                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3466                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3469                                 if (ndr->offset > ndr->relative_highest_offset) {
3470                                         ndr->relative_highest_offset = ndr->offset;
3471                                 }
3472                                 ndr->offset = _relative_save_offset;
3473                         }
3474                         ndr->flags = _flags_save_string;
3475                 }
3476                 {
3477                         uint32_t _flags_save_string = ndr->flags;
3478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3479                         if (r->text_status) {
3480                                 uint32_t _relative_save_offset;
3481                                 _relative_save_offset = ndr->offset;
3482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3483                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3484                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3487                                 if (ndr->offset > ndr->relative_highest_offset) {
3488                                         ndr->relative_highest_offset = ndr->offset;
3489                                 }
3490                                 ndr->offset = _relative_save_offset;
3491                         }
3492                         ndr->flags = _flags_save_string;
3493                 }
3494         }
3495         return NDR_ERR_SUCCESS;
3496 }
3497
3498 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3499 {
3500         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3501         ndr->depth++;
3502         ndr_print_uint32(ndr, "job_id", r->job_id);
3503         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3504         ndr->depth++;
3505         if (r->printer_name) {
3506                 ndr_print_string(ndr, "printer_name", r->printer_name);
3507         }
3508         ndr->depth--;
3509         ndr_print_ptr(ndr, "server_name", r->server_name);
3510         ndr->depth++;
3511         if (r->server_name) {
3512                 ndr_print_string(ndr, "server_name", r->server_name);
3513         }
3514         ndr->depth--;
3515         ndr_print_ptr(ndr, "user_name", r->user_name);
3516         ndr->depth++;
3517         if (r->user_name) {
3518                 ndr_print_string(ndr, "user_name", r->user_name);
3519         }
3520         ndr->depth--;
3521         ndr_print_ptr(ndr, "document_name", r->document_name);
3522         ndr->depth++;
3523         if (r->document_name) {
3524                 ndr_print_string(ndr, "document_name", r->document_name);
3525         }
3526         ndr->depth--;
3527         ndr_print_ptr(ndr, "data_type", r->data_type);
3528         ndr->depth++;
3529         if (r->data_type) {
3530                 ndr_print_string(ndr, "data_type", r->data_type);
3531         }
3532         ndr->depth--;
3533         ndr_print_ptr(ndr, "text_status", r->text_status);
3534         ndr->depth++;
3535         if (r->text_status) {
3536                 ndr_print_string(ndr, "text_status", r->text_status);
3537         }
3538         ndr->depth--;
3539         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3540         ndr_print_uint32(ndr, "priority", r->priority);
3541         ndr_print_uint32(ndr, "position", r->position);
3542         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3543         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3544         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3545         ndr->depth--;
3546 }
3547
3548 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3549 {
3550         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3551 }
3552
3553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3554 {
3555         if (ndr_flags & NDR_SCALARS) {
3556                 NDR_CHECK(ndr_push_align(ndr, 5));
3557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3558                 {
3559                         uint32_t _flags_save_string = ndr->flags;
3560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3562                         ndr->flags = _flags_save_string;
3563                 }
3564                 {
3565                         uint32_t _flags_save_string = ndr->flags;
3566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3568                         ndr->flags = _flags_save_string;
3569                 }
3570                 {
3571                         uint32_t _flags_save_string = ndr->flags;
3572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3574                         ndr->flags = _flags_save_string;
3575                 }
3576                 {
3577                         uint32_t _flags_save_string = ndr->flags;
3578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3580                         ndr->flags = _flags_save_string;
3581                 }
3582                 {
3583                         uint32_t _flags_save_string = ndr->flags;
3584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3586                         ndr->flags = _flags_save_string;
3587                 }
3588                 {
3589                         uint32_t _flags_save_string = ndr->flags;
3590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3592                         ndr->flags = _flags_save_string;
3593                 }
3594                 {
3595                         uint32_t _flags_save_string = ndr->flags;
3596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3598                         ndr->flags = _flags_save_string;
3599                 }
3600                 {
3601                         uint32_t _flags_save_string = ndr->flags;
3602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3603                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3604                         ndr->flags = _flags_save_string;
3605                 }
3606                 {
3607                         uint32_t _flags_save_string = ndr->flags;
3608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3610                         ndr->flags = _flags_save_string;
3611                 }
3612                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3613                 {
3614                         uint32_t _flags_save_string = ndr->flags;
3615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3617                         ndr->flags = _flags_save_string;
3618                 }
3619                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3620                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3627                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3630                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3631         }
3632         if (ndr_flags & NDR_BUFFERS) {
3633                 {
3634                         uint32_t _flags_save_string = ndr->flags;
3635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3636                         if (r->printer_name) {
3637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3639                         }
3640                         ndr->flags = _flags_save_string;
3641                 }
3642                 {
3643                         uint32_t _flags_save_string = ndr->flags;
3644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3645                         if (r->server_name) {
3646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3648                         }
3649                         ndr->flags = _flags_save_string;
3650                 }
3651                 {
3652                         uint32_t _flags_save_string = ndr->flags;
3653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3654                         if (r->user_name) {
3655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3657                         }
3658                         ndr->flags = _flags_save_string;
3659                 }
3660                 {
3661                         uint32_t _flags_save_string = ndr->flags;
3662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3663                         if (r->document_name) {
3664                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3666                         }
3667                         ndr->flags = _flags_save_string;
3668                 }
3669                 {
3670                         uint32_t _flags_save_string = ndr->flags;
3671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3672                         if (r->notify_name) {
3673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3675                         }
3676                         ndr->flags = _flags_save_string;
3677                 }
3678                 {
3679                         uint32_t _flags_save_string = ndr->flags;
3680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3681                         if (r->data_type) {
3682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3684                         }
3685                         ndr->flags = _flags_save_string;
3686                 }
3687                 {
3688                         uint32_t _flags_save_string = ndr->flags;
3689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3690                         if (r->print_processor) {
3691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3693                         }
3694                         ndr->flags = _flags_save_string;
3695                 }
3696                 {
3697                         uint32_t _flags_save_string = ndr->flags;
3698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3699                         if (r->parameters) {
3700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3702                         }
3703                         ndr->flags = _flags_save_string;
3704                 }
3705                 {
3706                         uint32_t _flags_save_string = ndr->flags;
3707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3708                         if (r->driver_name) {
3709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3711                         }
3712                         ndr->flags = _flags_save_string;
3713                 }
3714                 if (r->devmode) {
3715                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3716                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3717                 }
3718                 {
3719                         uint32_t _flags_save_string = ndr->flags;
3720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3721                         if (r->text_status) {
3722                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3723                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3724                         }
3725                         ndr->flags = _flags_save_string;
3726                 }
3727                 if (r->secdesc) {
3728                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3729                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3730                 }
3731         }
3732         return NDR_ERR_SUCCESS;
3733 }
3734
3735 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3736 {
3737         uint32_t _ptr_printer_name;
3738         TALLOC_CTX *_mem_save_printer_name_0;
3739         uint32_t _ptr_server_name;
3740         TALLOC_CTX *_mem_save_server_name_0;
3741         uint32_t _ptr_user_name;
3742         TALLOC_CTX *_mem_save_user_name_0;
3743         uint32_t _ptr_document_name;
3744         TALLOC_CTX *_mem_save_document_name_0;
3745         uint32_t _ptr_notify_name;
3746         TALLOC_CTX *_mem_save_notify_name_0;
3747         uint32_t _ptr_data_type;
3748         TALLOC_CTX *_mem_save_data_type_0;
3749         uint32_t _ptr_print_processor;
3750         TALLOC_CTX *_mem_save_print_processor_0;
3751         uint32_t _ptr_parameters;
3752         TALLOC_CTX *_mem_save_parameters_0;
3753         uint32_t _ptr_driver_name;
3754         TALLOC_CTX *_mem_save_driver_name_0;
3755         uint32_t _ptr_devmode;
3756         TALLOC_CTX *_mem_save_devmode_0;
3757         uint32_t _ptr_text_status;
3758         TALLOC_CTX *_mem_save_text_status_0;
3759         uint32_t _ptr_secdesc;
3760         TALLOC_CTX *_mem_save_secdesc_0;
3761         if (ndr_flags & NDR_SCALARS) {
3762                 NDR_CHECK(ndr_pull_align(ndr, 5));
3763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3768                         if (_ptr_printer_name) {
3769                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3771                         } else {
3772                                 r->printer_name = NULL;
3773                         }
3774                         ndr->flags = _flags_save_string;
3775                 }
3776                 {
3777                         uint32_t _flags_save_string = ndr->flags;
3778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3780                         if (_ptr_server_name) {
3781                                 NDR_PULL_ALLOC(ndr, r->server_name);
3782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3783                         } else {
3784                                 r->server_name = NULL;
3785                         }
3786                         ndr->flags = _flags_save_string;
3787                 }
3788                 {
3789                         uint32_t _flags_save_string = ndr->flags;
3790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3792                         if (_ptr_user_name) {
3793                                 NDR_PULL_ALLOC(ndr, r->user_name);
3794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3795                         } else {
3796                                 r->user_name = NULL;
3797                         }
3798                         ndr->flags = _flags_save_string;
3799                 }
3800                 {
3801                         uint32_t _flags_save_string = ndr->flags;
3802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3803                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3804                         if (_ptr_document_name) {
3805                                 NDR_PULL_ALLOC(ndr, r->document_name);
3806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3807                         } else {
3808                                 r->document_name = NULL;
3809                         }
3810                         ndr->flags = _flags_save_string;
3811                 }
3812                 {
3813                         uint32_t _flags_save_string = ndr->flags;
3814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3816                         if (_ptr_notify_name) {
3817                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3819                         } else {
3820                                 r->notify_name = NULL;
3821                         }
3822                         ndr->flags = _flags_save_string;
3823                 }
3824                 {
3825                         uint32_t _flags_save_string = ndr->flags;
3826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3827                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3828                         if (_ptr_data_type) {
3829                                 NDR_PULL_ALLOC(ndr, r->data_type);
3830                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3831                         } else {
3832                                 r->data_type = NULL;
3833                         }
3834                         ndr->flags = _flags_save_string;
3835                 }
3836                 {
3837                         uint32_t _flags_save_string = ndr->flags;
3838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3839                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3840                         if (_ptr_print_processor) {
3841                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3842                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3843                         } else {
3844                                 r->print_processor = NULL;
3845                         }
3846                         ndr->flags = _flags_save_string;
3847                 }
3848                 {
3849                         uint32_t _flags_save_string = ndr->flags;
3850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3851                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3852                         if (_ptr_parameters) {
3853                                 NDR_PULL_ALLOC(ndr, r->parameters);
3854                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3855                         } else {
3856                                 r->parameters = NULL;
3857                         }
3858                         ndr->flags = _flags_save_string;
3859                 }
3860                 {
3861                         uint32_t _flags_save_string = ndr->flags;
3862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3863                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3864                         if (_ptr_driver_name) {
3865                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3866                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3867                         } else {
3868                                 r->driver_name = NULL;
3869                         }
3870                         ndr->flags = _flags_save_string;
3871                 }
3872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3873                 if (_ptr_devmode) {
3874                         NDR_PULL_ALLOC(ndr, r->devmode);
3875                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3876                 } else {
3877                         r->devmode = NULL;
3878                 }
3879                 {
3880                         uint32_t _flags_save_string = ndr->flags;
3881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3883                         if (_ptr_text_status) {
3884                                 NDR_PULL_ALLOC(ndr, r->text_status);
3885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3886                         } else {
3887                                 r->text_status = NULL;
3888                         }
3889                         ndr->flags = _flags_save_string;
3890                 }
3891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3892                 if (_ptr_secdesc) {
3893                         NDR_PULL_ALLOC(ndr, r->secdesc);
3894                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3895                 } else {
3896                         r->secdesc = NULL;
3897                 }
3898                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3900                 if (r->priority > 99) {
3901                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3902                 }
3903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3908                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3911                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3912         }
3913         if (ndr_flags & NDR_BUFFERS) {
3914                 {
3915                         uint32_t _flags_save_string = ndr->flags;
3916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3917                         if (r->printer_name) {
3918                                 uint32_t _relative_save_offset;
3919                                 _relative_save_offset = ndr->offset;
3920                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3921                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3922                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3923                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3924                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3925                                 if (ndr->offset > ndr->relative_highest_offset) {
3926                                         ndr->relative_highest_offset = ndr->offset;
3927                                 }
3928                                 ndr->offset = _relative_save_offset;
3929                         }
3930                         ndr->flags = _flags_save_string;
3931                 }
3932                 {
3933                         uint32_t _flags_save_string = ndr->flags;
3934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3935                         if (r->server_name) {
3936                                 uint32_t _relative_save_offset;
3937                                 _relative_save_offset = ndr->offset;
3938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3939                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3940                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3943                                 if (ndr->offset > ndr->relative_highest_offset) {
3944                                         ndr->relative_highest_offset = ndr->offset;
3945                                 }
3946                                 ndr->offset = _relative_save_offset;
3947                         }
3948                         ndr->flags = _flags_save_string;
3949                 }
3950                 {
3951                         uint32_t _flags_save_string = ndr->flags;
3952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3953                         if (r->user_name) {
3954                                 uint32_t _relative_save_offset;
3955                                 _relative_save_offset = ndr->offset;
3956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3957                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3958                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3961                                 if (ndr->offset > ndr->relative_highest_offset) {
3962                                         ndr->relative_highest_offset = ndr->offset;
3963                                 }
3964                                 ndr->offset = _relative_save_offset;
3965                         }
3966                         ndr->flags = _flags_save_string;
3967                 }
3968                 {
3969                         uint32_t _flags_save_string = ndr->flags;
3970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3971                         if (r->document_name) {
3972                                 uint32_t _relative_save_offset;
3973                                 _relative_save_offset = ndr->offset;
3974                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3975                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3976                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3977                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3978                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3979                                 if (ndr->offset > ndr->relative_highest_offset) {
3980                                         ndr->relative_highest_offset = ndr->offset;
3981                                 }
3982                                 ndr->offset = _relative_save_offset;
3983                         }
3984                         ndr->flags = _flags_save_string;
3985                 }
3986                 {
3987                         uint32_t _flags_save_string = ndr->flags;
3988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3989                         if (r->notify_name) {
3990                                 uint32_t _relative_save_offset;
3991                                 _relative_save_offset = ndr->offset;
3992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3993                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3994                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3995                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3997                                 if (ndr->offset > ndr->relative_highest_offset) {
3998                                         ndr->relative_highest_offset = ndr->offset;
3999                                 }
4000                                 ndr->offset = _relative_save_offset;
4001                         }
4002                         ndr->flags = _flags_save_string;
4003                 }
4004                 {
4005                         uint32_t _flags_save_string = ndr->flags;
4006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4007                         if (r->data_type) {
4008                                 uint32_t _relative_save_offset;
4009                                 _relative_save_offset = ndr->offset;
4010                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4011                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4012                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4013                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4014                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4015                                 if (ndr->offset > ndr->relative_highest_offset) {
4016                                         ndr->relative_highest_offset = ndr->offset;
4017                                 }
4018                                 ndr->offset = _relative_save_offset;
4019                         }
4020                         ndr->flags = _flags_save_string;
4021                 }
4022                 {
4023                         uint32_t _flags_save_string = ndr->flags;
4024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4025                         if (r->print_processor) {
4026                                 uint32_t _relative_save_offset;
4027                                 _relative_save_offset = ndr->offset;
4028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4029                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4030                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4031                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4033                                 if (ndr->offset > ndr->relative_highest_offset) {
4034                                         ndr->relative_highest_offset = ndr->offset;
4035                                 }
4036                                 ndr->offset = _relative_save_offset;
4037                         }
4038                         ndr->flags = _flags_save_string;
4039                 }
4040                 {
4041                         uint32_t _flags_save_string = ndr->flags;
4042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4043                         if (r->parameters) {
4044                                 uint32_t _relative_save_offset;
4045                                 _relative_save_offset = ndr->offset;
4046                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4047                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4048                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4049                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4050                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4051                                 if (ndr->offset > ndr->relative_highest_offset) {
4052                                         ndr->relative_highest_offset = ndr->offset;
4053                                 }
4054                                 ndr->offset = _relative_save_offset;
4055                         }
4056                         ndr->flags = _flags_save_string;
4057                 }
4058                 {
4059                         uint32_t _flags_save_string = ndr->flags;
4060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4061                         if (r->driver_name) {
4062                                 uint32_t _relative_save_offset;
4063                                 _relative_save_offset = ndr->offset;
4064                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4065                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4066                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4067                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4069                                 if (ndr->offset > ndr->relative_highest_offset) {
4070                                         ndr->relative_highest_offset = ndr->offset;
4071                                 }
4072                                 ndr->offset = _relative_save_offset;
4073                         }
4074                         ndr->flags = _flags_save_string;
4075                 }
4076                 if (r->devmode) {
4077                         uint32_t _relative_save_offset;
4078                         _relative_save_offset = ndr->offset;
4079                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4080                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4081                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4082                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4084                         if (ndr->offset > ndr->relative_highest_offset) {
4085                                 ndr->relative_highest_offset = ndr->offset;
4086                         }
4087                         ndr->offset = _relative_save_offset;
4088                 }
4089                 {
4090                         uint32_t _flags_save_string = ndr->flags;
4091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4092                         if (r->text_status) {
4093                                 uint32_t _relative_save_offset;
4094                                 _relative_save_offset = ndr->offset;
4095                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4096                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4097                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4098                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4099                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4100                                 if (ndr->offset > ndr->relative_highest_offset) {
4101                                         ndr->relative_highest_offset = ndr->offset;
4102                                 }
4103                                 ndr->offset = _relative_save_offset;
4104                         }
4105                         ndr->flags = _flags_save_string;
4106                 }
4107                 if (r->secdesc) {
4108                         uint32_t _relative_save_offset;
4109                         _relative_save_offset = ndr->offset;
4110                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4111                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4112                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4113                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4115                         if (ndr->offset > ndr->relative_highest_offset) {
4116                                 ndr->relative_highest_offset = ndr->offset;
4117                         }
4118                         ndr->offset = _relative_save_offset;
4119                 }
4120         }
4121         return NDR_ERR_SUCCESS;
4122 }
4123
4124 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4125 {
4126         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4127         ndr->depth++;
4128         ndr_print_uint32(ndr, "job_id", r->job_id);
4129         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4130         ndr->depth++;
4131         if (r->printer_name) {
4132                 ndr_print_string(ndr, "printer_name", r->printer_name);
4133         }
4134         ndr->depth--;
4135         ndr_print_ptr(ndr, "server_name", r->server_name);
4136         ndr->depth++;
4137         if (r->server_name) {
4138                 ndr_print_string(ndr, "server_name", r->server_name);
4139         }
4140         ndr->depth--;
4141         ndr_print_ptr(ndr, "user_name", r->user_name);
4142         ndr->depth++;
4143         if (r->user_name) {
4144                 ndr_print_string(ndr, "user_name", r->user_name);
4145         }
4146         ndr->depth--;
4147         ndr_print_ptr(ndr, "document_name", r->document_name);
4148         ndr->depth++;
4149         if (r->document_name) {
4150                 ndr_print_string(ndr, "document_name", r->document_name);
4151         }
4152         ndr->depth--;
4153         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4154         ndr->depth++;
4155         if (r->notify_name) {
4156                 ndr_print_string(ndr, "notify_name", r->notify_name);
4157         }
4158         ndr->depth--;
4159         ndr_print_ptr(ndr, "data_type", r->data_type);
4160         ndr->depth++;
4161         if (r->data_type) {
4162                 ndr_print_string(ndr, "data_type", r->data_type);
4163         }
4164         ndr->depth--;
4165         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4166         ndr->depth++;
4167         if (r->print_processor) {
4168                 ndr_print_string(ndr, "print_processor", r->print_processor);
4169         }
4170         ndr->depth--;
4171         ndr_print_ptr(ndr, "parameters", r->parameters);
4172         ndr->depth++;
4173         if (r->parameters) {
4174                 ndr_print_string(ndr, "parameters", r->parameters);
4175         }
4176         ndr->depth--;
4177         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4178         ndr->depth++;
4179         if (r->driver_name) {
4180                 ndr_print_string(ndr, "driver_name", r->driver_name);
4181         }
4182         ndr->depth--;
4183         ndr_print_ptr(ndr, "devmode", r->devmode);
4184         ndr->depth++;
4185         if (r->devmode) {
4186                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4187         }
4188         ndr->depth--;
4189         ndr_print_ptr(ndr, "text_status", r->text_status);
4190         ndr->depth++;
4191         if (r->text_status) {
4192                 ndr_print_string(ndr, "text_status", r->text_status);
4193         }
4194         ndr->depth--;
4195         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4196         ndr->depth++;
4197         if (r->secdesc) {
4198                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4199         }
4200         ndr->depth--;
4201         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4202         ndr_print_uint32(ndr, "priority", r->priority);
4203         ndr_print_uint32(ndr, "position", r->position);
4204         ndr_print_uint32(ndr, "start_time", r->start_time);
4205         ndr_print_uint32(ndr, "until_time", r->until_time);
4206         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4207         ndr_print_uint32(ndr, "size", r->size);
4208         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4209         ndr_print_uint32(ndr, "time", r->time);
4210         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4211         ndr->depth--;
4212 }
4213
4214 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4215 {
4216         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4217 }
4218
4219 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4220 {
4221         if (ndr_flags & NDR_SCALARS) {
4222                 NDR_CHECK(ndr_push_align(ndr, 4));
4223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4226                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4227         }
4228         if (ndr_flags & NDR_BUFFERS) {
4229         }
4230         return NDR_ERR_SUCCESS;
4231 }
4232
4233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4234 {
4235         if (ndr_flags & NDR_SCALARS) {
4236                 NDR_CHECK(ndr_pull_align(ndr, 4));
4237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4240                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4241         }
4242         if (ndr_flags & NDR_BUFFERS) {
4243         }
4244         return NDR_ERR_SUCCESS;
4245 }
4246
4247 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4248 {
4249         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4250         ndr->depth++;
4251         ndr_print_uint32(ndr, "job_id", r->job_id);
4252         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4253         ndr_print_uint32(ndr, "reserved", r->reserved);
4254         ndr->depth--;
4255 }
4256
4257 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4258 {
4259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4260 }
4261
4262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4263 {
4264         if (ndr_flags & NDR_SCALARS) {
4265                 NDR_CHECK(ndr_push_align(ndr, 5));
4266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4267                 {
4268                         uint32_t _flags_save_string = ndr->flags;
4269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4270                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4271                         ndr->flags = _flags_save_string;
4272                 }
4273                 {
4274                         uint32_t _flags_save_string = ndr->flags;
4275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4276                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4277                         ndr->flags = _flags_save_string;
4278                 }
4279                 {
4280                         uint32_t _flags_save_string = ndr->flags;
4281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4282                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4283                         ndr->flags = _flags_save_string;
4284                 }
4285                 {
4286                         uint32_t _flags_save_string = ndr->flags;
4287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4289                         ndr->flags = _flags_save_string;
4290                 }
4291                 {
4292                         uint32_t _flags_save_string = ndr->flags;
4293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4295                         ndr->flags = _flags_save_string;
4296                 }
4297                 {
4298                         uint32_t _flags_save_string = ndr->flags;
4299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4301                         ndr->flags = _flags_save_string;
4302                 }
4303                 {
4304                         uint32_t _flags_save_string = ndr->flags;
4305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4307                         ndr->flags = _flags_save_string;
4308                 }
4309                 {
4310                         uint32_t _flags_save_string = ndr->flags;
4311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4313                         ndr->flags = _flags_save_string;
4314                 }
4315                 {
4316                         uint32_t _flags_save_string = ndr->flags;
4317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4319                         ndr->flags = _flags_save_string;
4320                 }
4321                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4322                 {
4323                         uint32_t _flags_save_string = ndr->flags;
4324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4325                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4326                         ndr->flags = _flags_save_string;
4327                 }
4328                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4329                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4336                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4341         }
4342         if (ndr_flags & NDR_BUFFERS) {
4343                 {
4344                         uint32_t _flags_save_string = ndr->flags;
4345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4346                         if (r->printer_name) {
4347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
4348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4349                         }
4350                         ndr->flags = _flags_save_string;
4351                 }
4352                 {
4353                         uint32_t _flags_save_string = ndr->flags;
4354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4355                         if (r->server_name) {
4356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
4357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4358                         }
4359                         ndr->flags = _flags_save_string;
4360                 }
4361                 {
4362                         uint32_t _flags_save_string = ndr->flags;
4363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4364                         if (r->user_name) {
4365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
4366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4367                         }
4368                         ndr->flags = _flags_save_string;
4369                 }
4370                 {
4371                         uint32_t _flags_save_string = ndr->flags;
4372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4373                         if (r->document_name) {
4374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
4375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4376                         }
4377                         ndr->flags = _flags_save_string;
4378                 }
4379                 {
4380                         uint32_t _flags_save_string = ndr->flags;
4381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4382                         if (r->notify_name) {
4383                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
4384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4385                         }
4386                         ndr->flags = _flags_save_string;
4387                 }
4388                 {
4389                         uint32_t _flags_save_string = ndr->flags;
4390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4391                         if (r->data_type) {
4392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
4393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4394                         }
4395                         ndr->flags = _flags_save_string;
4396                 }
4397                 {
4398                         uint32_t _flags_save_string = ndr->flags;
4399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4400                         if (r->print_processor) {
4401                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
4402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4403                         }
4404                         ndr->flags = _flags_save_string;
4405                 }
4406                 {
4407                         uint32_t _flags_save_string = ndr->flags;
4408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4409                         if (r->parameters) {
4410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
4411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4412                         }
4413                         ndr->flags = _flags_save_string;
4414                 }
4415                 {
4416                         uint32_t _flags_save_string = ndr->flags;
4417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4418                         if (r->driver_name) {
4419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4421                         }
4422                         ndr->flags = _flags_save_string;
4423                 }
4424                 if (r->devmode) {
4425                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
4426                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4427                 }
4428                 {
4429                         uint32_t _flags_save_string = ndr->flags;
4430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4431                         if (r->text_status) {
4432                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
4433                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4434                         }
4435                         ndr->flags = _flags_save_string;
4436                 }
4437                 if (r->secdesc) {
4438                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
4439                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4440                 }
4441         }
4442         return NDR_ERR_SUCCESS;
4443 }
4444
4445 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4446 {
4447         uint32_t _ptr_printer_name;
4448         TALLOC_CTX *_mem_save_printer_name_0;
4449         uint32_t _ptr_server_name;
4450         TALLOC_CTX *_mem_save_server_name_0;
4451         uint32_t _ptr_user_name;
4452         TALLOC_CTX *_mem_save_user_name_0;
4453         uint32_t _ptr_document_name;
4454         TALLOC_CTX *_mem_save_document_name_0;
4455         uint32_t _ptr_notify_name;
4456         TALLOC_CTX *_mem_save_notify_name_0;
4457         uint32_t _ptr_data_type;
4458         TALLOC_CTX *_mem_save_data_type_0;
4459         uint32_t _ptr_print_processor;
4460         TALLOC_CTX *_mem_save_print_processor_0;
4461         uint32_t _ptr_parameters;
4462         TALLOC_CTX *_mem_save_parameters_0;
4463         uint32_t _ptr_driver_name;
4464         TALLOC_CTX *_mem_save_driver_name_0;
4465         uint32_t _ptr_devmode;
4466         TALLOC_CTX *_mem_save_devmode_0;
4467         uint32_t _ptr_text_status;
4468         TALLOC_CTX *_mem_save_text_status_0;
4469         uint32_t _ptr_secdesc;
4470         TALLOC_CTX *_mem_save_secdesc_0;
4471         if (ndr_flags & NDR_SCALARS) {
4472                 NDR_CHECK(ndr_pull_align(ndr, 5));
4473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4474                 {
4475                         uint32_t _flags_save_string = ndr->flags;
4476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4477                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4478                         if (_ptr_printer_name) {
4479                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4480                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4481                         } else {
4482                                 r->printer_name = NULL;
4483                         }
4484                         ndr->flags = _flags_save_string;
4485                 }
4486                 {
4487                         uint32_t _flags_save_string = ndr->flags;
4488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4489                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4490                         if (_ptr_server_name) {
4491                                 NDR_PULL_ALLOC(ndr, r->server_name);
4492                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4493                         } else {
4494                                 r->server_name = NULL;
4495                         }
4496                         ndr->flags = _flags_save_string;
4497                 }
4498                 {
4499                         uint32_t _flags_save_string = ndr->flags;
4500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4501                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4502                         if (_ptr_user_name) {
4503                                 NDR_PULL_ALLOC(ndr, r->user_name);
4504                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4505                         } else {
4506                                 r->user_name = NULL;
4507                         }
4508                         ndr->flags = _flags_save_string;
4509                 }
4510                 {
4511                         uint32_t _flags_save_string = ndr->flags;
4512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4514                         if (_ptr_document_name) {
4515                                 NDR_PULL_ALLOC(ndr, r->document_name);
4516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4517                         } else {
4518                                 r->document_name = NULL;
4519                         }
4520                         ndr->flags = _flags_save_string;
4521                 }
4522                 {
4523                         uint32_t _flags_save_string = ndr->flags;
4524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4525                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4526                         if (_ptr_notify_name) {
4527                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4528                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4529                         } else {
4530                                 r->notify_name = NULL;
4531                         }
4532                         ndr->flags = _flags_save_string;
4533                 }
4534                 {
4535                         uint32_t _flags_save_string = ndr->flags;
4536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4538                         if (_ptr_data_type) {
4539                                 NDR_PULL_ALLOC(ndr, r->data_type);
4540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4541                         } else {
4542                                 r->data_type = NULL;
4543                         }
4544                         ndr->flags = _flags_save_string;
4545                 }
4546                 {
4547                         uint32_t _flags_save_string = ndr->flags;
4548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4550                         if (_ptr_print_processor) {
4551                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4553                         } else {
4554                                 r->print_processor = NULL;
4555                         }
4556                         ndr->flags = _flags_save_string;
4557                 }
4558                 {
4559                         uint32_t _flags_save_string = ndr->flags;
4560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4562                         if (_ptr_parameters) {
4563                                 NDR_PULL_ALLOC(ndr, r->parameters);
4564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4565                         } else {
4566                                 r->parameters = NULL;
4567                         }
4568                         ndr->flags = _flags_save_string;
4569                 }
4570                 {
4571                         uint32_t _flags_save_string = ndr->flags;
4572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4573                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4574                         if (_ptr_driver_name) {
4575                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4576                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4577                         } else {
4578                                 r->driver_name = NULL;
4579                         }
4580                         ndr->flags = _flags_save_string;
4581                 }
4582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4583                 if (_ptr_devmode) {
4584                         NDR_PULL_ALLOC(ndr, r->devmode);
4585                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4586                 } else {
4587                         r->devmode = NULL;
4588                 }
4589                 {
4590                         uint32_t _flags_save_string = ndr->flags;
4591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4592                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4593                         if (_ptr_text_status) {
4594                                 NDR_PULL_ALLOC(ndr, r->text_status);
4595                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4596                         } else {
4597                                 r->text_status = NULL;
4598                         }
4599                         ndr->flags = _flags_save_string;
4600                 }
4601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4602                 if (_ptr_secdesc) {
4603                         NDR_PULL_ALLOC(ndr, r->secdesc);
4604                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4605                 } else {
4606                         r->secdesc = NULL;
4607                 }
4608                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4610                 if (r->priority > 99) {
4611                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4612                 }
4613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4618                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4623         }
4624         if (ndr_flags & NDR_BUFFERS) {
4625                 {
4626                         uint32_t _flags_save_string = ndr->flags;
4627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4628                         if (r->printer_name) {
4629                                 uint32_t _relative_save_offset;
4630                                 _relative_save_offset = ndr->offset;
4631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4632                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4633                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4636                                 if (ndr->offset > ndr->relative_highest_offset) {
4637                                         ndr->relative_highest_offset = ndr->offset;
4638                                 }
4639                                 ndr->offset = _relative_save_offset;
4640                         }
4641                         ndr->flags = _flags_save_string;
4642                 }
4643                 {
4644                         uint32_t _flags_save_string = ndr->flags;
4645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4646                         if (r->server_name) {
4647                                 uint32_t _relative_save_offset;
4648                                 _relative_save_offset = ndr->offset;
4649                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4650                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4651                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4652                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4653                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4654                                 if (ndr->offset > ndr->relative_highest_offset) {
4655                                         ndr->relative_highest_offset = ndr->offset;
4656                                 }
4657                                 ndr->offset = _relative_save_offset;
4658                         }
4659                         ndr->flags = _flags_save_string;
4660                 }
4661                 {
4662                         uint32_t _flags_save_string = ndr->flags;
4663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4664                         if (r->user_name) {
4665                                 uint32_t _relative_save_offset;
4666                                 _relative_save_offset = ndr->offset;
4667                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4668                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4669                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4670                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4671                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4672                                 if (ndr->offset > ndr->relative_highest_offset) {
4673                                         ndr->relative_highest_offset = ndr->offset;
4674                                 }
4675                                 ndr->offset = _relative_save_offset;
4676                         }
4677                         ndr->flags = _flags_save_string;
4678                 }
4679                 {
4680                         uint32_t _flags_save_string = ndr->flags;
4681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4682                         if (r->document_name) {
4683                                 uint32_t _relative_save_offset;
4684                                 _relative_save_offset = ndr->offset;
4685                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4686                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4687                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4688                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4689                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4690                                 if (ndr->offset > ndr->relative_highest_offset) {
4691                                         ndr->relative_highest_offset = ndr->offset;
4692                                 }
4693                                 ndr->offset = _relative_save_offset;
4694                         }
4695                         ndr->flags = _flags_save_string;
4696                 }
4697                 {
4698                         uint32_t _flags_save_string = ndr->flags;
4699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4700                         if (r->notify_name) {
4701                                 uint32_t _relative_save_offset;
4702                                 _relative_save_offset = ndr->offset;
4703                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4704                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4705                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4706                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4707                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4708                                 if (ndr->offset > ndr->relative_highest_offset) {
4709                                         ndr->relative_highest_offset = ndr->offset;
4710                                 }
4711                                 ndr->offset = _relative_save_offset;
4712                         }
4713                         ndr->flags = _flags_save_string;
4714                 }
4715                 {
4716                         uint32_t _flags_save_string = ndr->flags;
4717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4718                         if (r->data_type) {
4719                                 uint32_t _relative_save_offset;
4720                                 _relative_save_offset = ndr->offset;
4721                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4722                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4723                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4724                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4725                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4726                                 if (ndr->offset > ndr->relative_highest_offset) {
4727                                         ndr->relative_highest_offset = ndr->offset;
4728                                 }
4729                                 ndr->offset = _relative_save_offset;
4730                         }
4731                         ndr->flags = _flags_save_string;
4732                 }
4733                 {
4734                         uint32_t _flags_save_string = ndr->flags;
4735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4736                         if (r->print_processor) {
4737                                 uint32_t _relative_save_offset;
4738                                 _relative_save_offset = ndr->offset;
4739                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4740                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4741                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4742                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4743                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4744                                 if (ndr->offset > ndr->relative_highest_offset) {
4745                                         ndr->relative_highest_offset = ndr->offset;
4746                                 }
4747                                 ndr->offset = _relative_save_offset;
4748                         }
4749                         ndr->flags = _flags_save_string;
4750                 }
4751                 {
4752                         uint32_t _flags_save_string = ndr->flags;
4753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4754                         if (r->parameters) {
4755                                 uint32_t _relative_save_offset;
4756                                 _relative_save_offset = ndr->offset;
4757                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4758                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4759                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4760                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4761                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4762                                 if (ndr->offset > ndr->relative_highest_offset) {
4763                                         ndr->relative_highest_offset = ndr->offset;
4764                                 }
4765                                 ndr->offset = _relative_save_offset;
4766                         }
4767                         ndr->flags = _flags_save_string;
4768                 }
4769                 {
4770                         uint32_t _flags_save_string = ndr->flags;
4771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4772                         if (r->driver_name) {
4773                                 uint32_t _relative_save_offset;
4774                                 _relative_save_offset = ndr->offset;
4775                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4776                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4777                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4778                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4779                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4780                                 if (ndr->offset > ndr->relative_highest_offset) {
4781                                         ndr->relative_highest_offset = ndr->offset;
4782                                 }
4783                                 ndr->offset = _relative_save_offset;
4784                         }
4785                         ndr->flags = _flags_save_string;
4786                 }
4787                 if (r->devmode) {
4788                         uint32_t _relative_save_offset;
4789                         _relative_save_offset = ndr->offset;
4790                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4791                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4792                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4793                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4795                         if (ndr->offset > ndr->relative_highest_offset) {
4796                                 ndr->relative_highest_offset = ndr->offset;
4797                         }
4798                         ndr->offset = _relative_save_offset;
4799                 }
4800                 {
4801                         uint32_t _flags_save_string = ndr->flags;
4802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4803                         if (r->text_status) {
4804                                 uint32_t _relative_save_offset;
4805                                 _relative_save_offset = ndr->offset;
4806                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4807                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4808                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4809                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4810                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4811                                 if (ndr->offset > ndr->relative_highest_offset) {
4812                                         ndr->relative_highest_offset = ndr->offset;
4813                                 }
4814                                 ndr->offset = _relative_save_offset;
4815                         }
4816                         ndr->flags = _flags_save_string;
4817                 }
4818                 if (r->secdesc) {
4819                         uint32_t _relative_save_offset;
4820                         _relative_save_offset = ndr->offset;
4821                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4822                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4823                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4824                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4826                         if (ndr->offset > ndr->relative_highest_offset) {
4827                                 ndr->relative_highest_offset = ndr->offset;
4828                         }
4829                         ndr->offset = _relative_save_offset;
4830                 }
4831         }
4832         return NDR_ERR_SUCCESS;
4833 }
4834
4835 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4836 {
4837         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4838         ndr->depth++;
4839         ndr_print_uint32(ndr, "job_id", r->job_id);
4840         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4841         ndr->depth++;
4842         if (r->printer_name) {
4843                 ndr_print_string(ndr, "printer_name", r->printer_name);
4844         }
4845         ndr->depth--;
4846         ndr_print_ptr(ndr, "server_name", r->server_name);
4847         ndr->depth++;
4848         if (r->server_name) {
4849                 ndr_print_string(ndr, "server_name", r->server_name);
4850         }
4851         ndr->depth--;
4852         ndr_print_ptr(ndr, "user_name", r->user_name);
4853         ndr->depth++;
4854         if (r->user_name) {
4855                 ndr_print_string(ndr, "user_name", r->user_name);
4856         }
4857         ndr->depth--;
4858         ndr_print_ptr(ndr, "document_name", r->document_name);
4859         ndr->depth++;
4860         if (r->document_name) {
4861                 ndr_print_string(ndr, "document_name", r->document_name);
4862         }
4863         ndr->depth--;
4864         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4865         ndr->depth++;
4866         if (r->notify_name) {
4867                 ndr_print_string(ndr, "notify_name", r->notify_name);
4868         }
4869         ndr->depth--;
4870         ndr_print_ptr(ndr, "data_type", r->data_type);
4871         ndr->depth++;
4872         if (r->data_type) {
4873                 ndr_print_string(ndr, "data_type", r->data_type);
4874         }
4875         ndr->depth--;
4876         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4877         ndr->depth++;
4878         if (r->print_processor) {
4879                 ndr_print_string(ndr, "print_processor", r->print_processor);
4880         }
4881         ndr->depth--;
4882         ndr_print_ptr(ndr, "parameters", r->parameters);
4883         ndr->depth++;
4884         if (r->parameters) {
4885                 ndr_print_string(ndr, "parameters", r->parameters);
4886         }
4887         ndr->depth--;
4888         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4889         ndr->depth++;
4890         if (r->driver_name) {
4891                 ndr_print_string(ndr, "driver_name", r->driver_name);
4892         }
4893         ndr->depth--;
4894         ndr_print_ptr(ndr, "devmode", r->devmode);
4895         ndr->depth++;
4896         if (r->devmode) {
4897                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4898         }
4899         ndr->depth--;
4900         ndr_print_ptr(ndr, "text_status", r->text_status);
4901         ndr->depth++;
4902         if (r->text_status) {
4903                 ndr_print_string(ndr, "text_status", r->text_status);
4904         }
4905         ndr->depth--;
4906         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4907         ndr->depth++;
4908         if (r->secdesc) {
4909                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4910         }
4911         ndr->depth--;
4912         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4913         ndr_print_uint32(ndr, "priority", r->priority);
4914         ndr_print_uint32(ndr, "position", r->position);
4915         ndr_print_uint32(ndr, "start_time", r->start_time);
4916         ndr_print_uint32(ndr, "until_time", r->until_time);
4917         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4918         ndr_print_uint32(ndr, "size", r->size);
4919         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4920         ndr_print_uint32(ndr, "time", r->time);
4921         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4922         ndr_print_uint32(ndr, "size_high", r->size_high);
4923         ndr->depth--;
4924 }
4925
4926 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4927 {
4928         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4929 }
4930
4931 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4932 {
4933         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4934         if (ndr_flags & NDR_SCALARS) {
4935                 int level = ndr_push_get_switch_value(ndr, r);
4936                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4937                 switch (level) {
4938                         case 1: {
4939                                 NDR_CHECK(ndr_push_align(ndr, 5));
4940                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4941                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4942                         break; }
4943
4944                         case 2: {
4945                                 NDR_CHECK(ndr_push_align(ndr, 5));
4946                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4947                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4948                         break; }
4949
4950                         case 3: {
4951                                 NDR_CHECK(ndr_push_align(ndr, 4));
4952                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4953                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4954                         break; }
4955
4956                         case 4: {
4957                                 NDR_CHECK(ndr_push_align(ndr, 5));
4958                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4959                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4960                         break; }
4961
4962                         default: {
4963                         break; }
4964
4965                 }
4966         }
4967         if (ndr_flags & NDR_BUFFERS) {
4968                 int level = ndr_push_get_switch_value(ndr, r);
4969                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4970                 switch (level) {
4971                         case 1:
4972                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4973                         break;
4974
4975                         case 2:
4976                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4977                         break;
4978
4979                         case 3:
4980                         break;
4981
4982                         case 4:
4983                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4984                         break;
4985
4986                         default:
4987                         break;
4988
4989                 }
4990         }
4991         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4992         return NDR_ERR_SUCCESS;
4993 }
4994
4995 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4996 {
4997         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4998         int level;
4999         level = ndr_pull_get_switch_value(ndr, r);
5000         if (ndr_flags & NDR_SCALARS) {
5001                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5002                 switch (level) {
5003                         case 1: {
5004                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5005                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5006                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5007                         break; }
5008
5009                         case 2: {
5010                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5011                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5012                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5013                         break; }
5014
5015                         case 3: {
5016                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5017                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5018                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5019                         break; }
5020
5021                         case 4: {
5022                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5023                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5024                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5025                         break; }
5026
5027                         default: {
5028                         break; }
5029
5030                 }
5031         }
5032         if (ndr_flags & NDR_BUFFERS) {
5033                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5034                 switch (level) {
5035                         case 1:
5036                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5037                         break;
5038
5039                         case 2:
5040                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5041                         break;
5042
5043                         case 3:
5044                         break;
5045
5046                         case 4:
5047                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5048                         break;
5049
5050                         default:
5051                         break;
5052
5053                 }
5054         }
5055         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5056         return NDR_ERR_SUCCESS;
5057 }
5058
5059 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5060 {
5061         int level;
5062         level = ndr_print_get_switch_value(ndr, r);
5063         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5064         switch (level) {
5065                 case 1:
5066                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5067                 break;
5068
5069                 case 2:
5070                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5071                 break;
5072
5073                 case 3:
5074                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5075                 break;
5076
5077                 case 4:
5078                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5079                 break;
5080
5081                 default:
5082                 break;
5083
5084         }
5085 }
5086
5087 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5088 {
5089         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5090 }
5091
5092 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5093 {
5094         if (ndr_flags & NDR_SCALARS) {
5095                 NDR_CHECK(ndr_push_align(ndr, 5));
5096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5103                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5108                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5109                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5110         }
5111         if (ndr_flags & NDR_BUFFERS) {
5112                 if (r->printer_name) {
5113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5116                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5117                 }
5118                 if (r->server_name) {
5119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5122                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5123                 }
5124                 if (r->user_name) {
5125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5129                 }
5130                 if (r->document_name) {
5131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5134                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5135                 }
5136                 if (r->data_type) {
5137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5141                 }
5142                 if (r->text_status) {
5143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5146                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5147                 }
5148         }
5149         return NDR_ERR_SUCCESS;
5150 }
5151
5152 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5153 {
5154         uint32_t _ptr_printer_name;
5155         TALLOC_CTX *_mem_save_printer_name_0;
5156         uint32_t _ptr_server_name;
5157         TALLOC_CTX *_mem_save_server_name_0;
5158         uint32_t _ptr_user_name;
5159         TALLOC_CTX *_mem_save_user_name_0;
5160         uint32_t _ptr_document_name;
5161         TALLOC_CTX *_mem_save_document_name_0;
5162         uint32_t _ptr_data_type;
5163         TALLOC_CTX *_mem_save_data_type_0;
5164         uint32_t _ptr_text_status;
5165         TALLOC_CTX *_mem_save_text_status_0;
5166         if (ndr_flags & NDR_SCALARS) {
5167                 NDR_CHECK(ndr_pull_align(ndr, 5));
5168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5170                 if (_ptr_printer_name) {
5171                         NDR_PULL_ALLOC(ndr, r->printer_name);
5172                 } else {
5173                         r->printer_name = NULL;
5174                 }
5175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5176                 if (_ptr_server_name) {
5177                         NDR_PULL_ALLOC(ndr, r->server_name);
5178                 } else {
5179                         r->server_name = NULL;
5180                 }
5181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5182                 if (_ptr_user_name) {
5183                         NDR_PULL_ALLOC(ndr, r->user_name);
5184                 } else {
5185                         r->user_name = NULL;
5186                 }
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5188                 if (_ptr_document_name) {
5189                         NDR_PULL_ALLOC(ndr, r->document_name);
5190                 } else {
5191                         r->document_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5194                 if (_ptr_data_type) {
5195                         NDR_PULL_ALLOC(ndr, r->data_type);
5196                 } else {
5197                         r->data_type = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5200                 if (_ptr_text_status) {
5201                         NDR_PULL_ALLOC(ndr, r->text_status);
5202                 } else {
5203                         r->text_status = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5207                 if (r->priority > 99) {
5208                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5209                 }
5210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5213                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5214                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5215         }
5216         if (ndr_flags & NDR_BUFFERS) {
5217                 if (r->printer_name) {
5218                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5219                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5222                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5224                         }
5225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5228                 }
5229                 if (r->server_name) {
5230                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5231                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5234                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5236                         }
5237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5240                 }
5241                 if (r->user_name) {
5242                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5243                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5246                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5247                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5248                         }
5249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5252                 }
5253                 if (r->document_name) {
5254                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5255                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5258                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5259                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5260                         }
5261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5264                 }
5265                 if (r->data_type) {
5266                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5270                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5271                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5272                         }
5273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5276                 }
5277                 if (r->text_status) {
5278                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5282                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5283                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5284                         }
5285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5288                 }
5289         }
5290         return NDR_ERR_SUCCESS;
5291 }
5292
5293 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5294 {
5295         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5296         ndr->depth++;
5297         ndr_print_uint32(ndr, "job_id", r->job_id);
5298         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5299         ndr->depth++;
5300         if (r->printer_name) {
5301                 ndr_print_string(ndr, "printer_name", r->printer_name);
5302         }
5303         ndr->depth--;
5304         ndr_print_ptr(ndr, "server_name", r->server_name);
5305         ndr->depth++;
5306         if (r->server_name) {
5307                 ndr_print_string(ndr, "server_name", r->server_name);
5308         }
5309         ndr->depth--;
5310         ndr_print_ptr(ndr, "user_name", r->user_name);
5311         ndr->depth++;
5312         if (r->user_name) {
5313                 ndr_print_string(ndr, "user_name", r->user_name);
5314         }
5315         ndr->depth--;
5316         ndr_print_ptr(ndr, "document_name", r->document_name);
5317         ndr->depth++;
5318         if (r->document_name) {
5319                 ndr_print_string(ndr, "document_name", r->document_name);
5320         }
5321         ndr->depth--;
5322         ndr_print_ptr(ndr, "data_type", r->data_type);
5323         ndr->depth++;
5324         if (r->data_type) {
5325                 ndr_print_string(ndr, "data_type", r->data_type);
5326         }
5327         ndr->depth--;
5328         ndr_print_ptr(ndr, "text_status", r->text_status);
5329         ndr->depth++;
5330         if (r->text_status) {
5331                 ndr_print_string(ndr, "text_status", r->text_status);
5332         }
5333         ndr->depth--;
5334         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5335         ndr_print_uint32(ndr, "priority", r->priority);
5336         ndr_print_uint32(ndr, "position", r->position);
5337         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5338         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5339         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5340         ndr->depth--;
5341 }
5342
5343 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5344 {
5345         if (ndr_flags & NDR_SCALARS) {
5346                 NDR_CHECK(ndr_push_align(ndr, 5));
5347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5360                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5367                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5370                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5371         }
5372         if (ndr_flags & NDR_BUFFERS) {
5373                 if (r->printer_name) {
5374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5378                 }
5379                 if (r->server_name) {
5380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5383                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5384                 }
5385                 if (r->user_name) {
5386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5387                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5390                 }
5391                 if (r->document_name) {
5392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5396                 }
5397                 if (r->notify_name) {
5398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5402                 }
5403                 if (r->data_type) {
5404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5408                 }
5409                 if (r->print_processor) {
5410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5413                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5414                 }
5415                 if (r->parameters) {
5416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5419                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5420                 }
5421                 if (r->driver_name) {
5422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5426                 }
5427                 if (r->text_status) {
5428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5432                 }
5433         }
5434         return NDR_ERR_SUCCESS;
5435 }
5436
5437 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5438 {
5439         uint32_t _ptr_printer_name;
5440         TALLOC_CTX *_mem_save_printer_name_0;
5441         uint32_t _ptr_server_name;
5442         TALLOC_CTX *_mem_save_server_name_0;
5443         uint32_t _ptr_user_name;
5444         TALLOC_CTX *_mem_save_user_name_0;
5445         uint32_t _ptr_document_name;
5446         TALLOC_CTX *_mem_save_document_name_0;
5447         uint32_t _ptr_notify_name;
5448         TALLOC_CTX *_mem_save_notify_name_0;
5449         uint32_t _ptr_data_type;
5450         TALLOC_CTX *_mem_save_data_type_0;
5451         uint32_t _ptr_print_processor;
5452         TALLOC_CTX *_mem_save_print_processor_0;
5453         uint32_t _ptr_parameters;
5454         TALLOC_CTX *_mem_save_parameters_0;
5455         uint32_t _ptr_driver_name;
5456         TALLOC_CTX *_mem_save_driver_name_0;
5457         uint32_t _ptr_text_status;
5458         TALLOC_CTX *_mem_save_text_status_0;
5459         if (ndr_flags & NDR_SCALARS) {
5460                 NDR_CHECK(ndr_pull_align(ndr, 5));
5461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5463                 if (_ptr_printer_name) {
5464                         NDR_PULL_ALLOC(ndr, r->printer_name);
5465                 } else {
5466                         r->printer_name = NULL;
5467                 }
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5469                 if (_ptr_server_name) {
5470                         NDR_PULL_ALLOC(ndr, r->server_name);
5471                 } else {
5472                         r->server_name = NULL;
5473                 }
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5475                 if (_ptr_user_name) {
5476                         NDR_PULL_ALLOC(ndr, r->user_name);
5477                 } else {
5478                         r->user_name = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5481                 if (_ptr_document_name) {
5482                         NDR_PULL_ALLOC(ndr, r->document_name);
5483                 } else {
5484                         r->document_name = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5487                 if (_ptr_notify_name) {
5488                         NDR_PULL_ALLOC(ndr, r->notify_name);
5489                 } else {
5490                         r->notify_name = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5493                 if (_ptr_data_type) {
5494                         NDR_PULL_ALLOC(ndr, r->data_type);
5495                 } else {
5496                         r->data_type = NULL;
5497                 }
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5499                 if (_ptr_print_processor) {
5500                         NDR_PULL_ALLOC(ndr, r->print_processor);
5501                 } else {
5502                         r->print_processor = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5505                 if (_ptr_parameters) {
5506                         NDR_PULL_ALLOC(ndr, r->parameters);
5507                 } else {
5508                         r->parameters = NULL;
5509                 }
5510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5511                 if (_ptr_driver_name) {
5512                         NDR_PULL_ALLOC(ndr, r->driver_name);
5513                 } else {
5514                         r->driver_name = NULL;
5515                 }
5516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5518                 if (_ptr_text_status) {
5519                         NDR_PULL_ALLOC(ndr, r->text_status);
5520                 } else {
5521                         r->text_status = NULL;
5522                 }
5523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5524                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5526                 if (r->priority > 99) {
5527                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5528                 }
5529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5534                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5538         }
5539         if (ndr_flags & NDR_BUFFERS) {
5540                 if (r->printer_name) {
5541                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5542                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5545                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5546                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5547                         }
5548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5551                 }
5552                 if (r->server_name) {
5553                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5554                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5557                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5559                         }
5560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5563                 }
5564                 if (r->user_name) {
5565                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5566                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5569                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5570                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5571                         }
5572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5575                 }
5576                 if (r->document_name) {
5577                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5578                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5581                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5582                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5583                         }
5584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5587                 }
5588                 if (r->notify_name) {
5589                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5590                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5593                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5594                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5595                         }
5596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5599                 }
5600                 if (r->data_type) {
5601                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5602                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5603                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5604                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5605                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5606                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5607                         }
5608                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5609                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5611                 }
5612                 if (r->print_processor) {
5613                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5617                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5618                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5619                         }
5620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5623                 }
5624                 if (r->parameters) {
5625                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5626                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5629                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5630                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5631                         }
5632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5635                 }
5636                 if (r->driver_name) {
5637                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5638                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5641                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5642                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5643                         }
5644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5647                 }
5648                 if (r->text_status) {
5649                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5650                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5653                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5654                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5655                         }
5656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5659                 }
5660         }
5661         return NDR_ERR_SUCCESS;
5662 }
5663
5664 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5665 {
5666         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5667         ndr->depth++;
5668         ndr_print_uint32(ndr, "job_id", r->job_id);
5669         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5670         ndr->depth++;
5671         if (r->printer_name) {
5672                 ndr_print_string(ndr, "printer_name", r->printer_name);
5673         }
5674         ndr->depth--;
5675         ndr_print_ptr(ndr, "server_name", r->server_name);
5676         ndr->depth++;
5677         if (r->server_name) {
5678                 ndr_print_string(ndr, "server_name", r->server_name);
5679         }
5680         ndr->depth--;
5681         ndr_print_ptr(ndr, "user_name", r->user_name);
5682         ndr->depth++;
5683         if (r->user_name) {
5684                 ndr_print_string(ndr, "user_name", r->user_name);
5685         }
5686         ndr->depth--;
5687         ndr_print_ptr(ndr, "document_name", r->document_name);
5688         ndr->depth++;
5689         if (r->document_name) {
5690                 ndr_print_string(ndr, "document_name", r->document_name);
5691         }
5692         ndr->depth--;
5693         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5694         ndr->depth++;
5695         if (r->notify_name) {
5696                 ndr_print_string(ndr, "notify_name", r->notify_name);
5697         }
5698         ndr->depth--;
5699         ndr_print_ptr(ndr, "data_type", r->data_type);
5700         ndr->depth++;
5701         if (r->data_type) {
5702                 ndr_print_string(ndr, "data_type", r->data_type);
5703         }
5704         ndr->depth--;
5705         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5706         ndr->depth++;
5707         if (r->print_processor) {
5708                 ndr_print_string(ndr, "print_processor", r->print_processor);
5709         }
5710         ndr->depth--;
5711         ndr_print_ptr(ndr, "parameters", r->parameters);
5712         ndr->depth++;
5713         if (r->parameters) {
5714                 ndr_print_string(ndr, "parameters", r->parameters);
5715         }
5716         ndr->depth--;
5717         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5718         ndr->depth++;
5719         if (r->driver_name) {
5720                 ndr_print_string(ndr, "driver_name", r->driver_name);
5721         }
5722         ndr->depth--;
5723         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5724         ndr_print_ptr(ndr, "text_status", r->text_status);
5725         ndr->depth++;
5726         if (r->text_status) {
5727                 ndr_print_string(ndr, "text_status", r->text_status);
5728         }
5729         ndr->depth--;
5730         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5731         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5732         ndr_print_uint32(ndr, "priority", r->priority);
5733         ndr_print_uint32(ndr, "position", r->position);
5734         ndr_print_uint32(ndr, "start_time", r->start_time);
5735         ndr_print_uint32(ndr, "until_time", r->until_time);
5736         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5737         ndr_print_uint32(ndr, "size", r->size);
5738         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5739         ndr_print_uint32(ndr, "time", r->time);
5740         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5741         ndr->depth--;
5742 }
5743
5744 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5745 {
5746         if (ndr_flags & NDR_SCALARS) {
5747                 NDR_CHECK(ndr_push_align(ndr, 5));
5748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5756                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5761                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5768                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5772                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5773         }
5774         if (ndr_flags & NDR_BUFFERS) {
5775                 if (r->printer_name) {
5776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5780                 }
5781                 if (r->server_name) {
5782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5786                 }
5787                 if (r->user_name) {
5788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5792                 }
5793                 if (r->document_name) {
5794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5798                 }
5799                 if (r->notify_name) {
5800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5804                 }
5805                 if (r->data_type) {
5806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5810                 }
5811                 if (r->print_processor) {
5812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5816                 }
5817                 if (r->parameters) {
5818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5822                 }
5823                 if (r->driver_name) {
5824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5828                 }
5829                 if (r->text_status) {
5830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5833                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5834                 }
5835         }
5836         return NDR_ERR_SUCCESS;
5837 }
5838
5839 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5840 {
5841         uint32_t _ptr_printer_name;
5842         TALLOC_CTX *_mem_save_printer_name_0;
5843         uint32_t _ptr_server_name;
5844         TALLOC_CTX *_mem_save_server_name_0;
5845         uint32_t _ptr_user_name;
5846         TALLOC_CTX *_mem_save_user_name_0;
5847         uint32_t _ptr_document_name;
5848         TALLOC_CTX *_mem_save_document_name_0;
5849         uint32_t _ptr_notify_name;
5850         TALLOC_CTX *_mem_save_notify_name_0;
5851         uint32_t _ptr_data_type;
5852         TALLOC_CTX *_mem_save_data_type_0;
5853         uint32_t _ptr_print_processor;
5854         TALLOC_CTX *_mem_save_print_processor_0;
5855         uint32_t _ptr_parameters;
5856         TALLOC_CTX *_mem_save_parameters_0;
5857         uint32_t _ptr_driver_name;
5858         TALLOC_CTX *_mem_save_driver_name_0;
5859         uint32_t _ptr_text_status;
5860         TALLOC_CTX *_mem_save_text_status_0;
5861         if (ndr_flags & NDR_SCALARS) {
5862                 NDR_CHECK(ndr_pull_align(ndr, 5));
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5865                 if (_ptr_printer_name) {
5866                         NDR_PULL_ALLOC(ndr, r->printer_name);
5867                 } else {
5868                         r->printer_name = NULL;
5869                 }
5870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5871                 if (_ptr_server_name) {
5872                         NDR_PULL_ALLOC(ndr, r->server_name);
5873                 } else {
5874                         r->server_name = NULL;
5875                 }
5876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5877                 if (_ptr_user_name) {
5878                         NDR_PULL_ALLOC(ndr, r->user_name);
5879                 } else {
5880                         r->user_name = NULL;
5881                 }
5882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5883                 if (_ptr_document_name) {
5884                         NDR_PULL_ALLOC(ndr, r->document_name);
5885                 } else {
5886                         r->document_name = NULL;
5887                 }
5888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5889                 if (_ptr_notify_name) {
5890                         NDR_PULL_ALLOC(ndr, r->notify_name);
5891                 } else {
5892                         r->notify_name = NULL;
5893                 }
5894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5895                 if (_ptr_data_type) {
5896                         NDR_PULL_ALLOC(ndr, r->data_type);
5897                 } else {
5898                         r->data_type = NULL;
5899                 }
5900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5901                 if (_ptr_print_processor) {
5902                         NDR_PULL_ALLOC(ndr, r->print_processor);
5903                 } else {
5904                         r->print_processor = NULL;
5905                 }
5906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5907                 if (_ptr_parameters) {
5908                         NDR_PULL_ALLOC(ndr, r->parameters);
5909                 } else {
5910                         r->parameters = NULL;
5911                 }
5912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5913                 if (_ptr_driver_name) {
5914                         NDR_PULL_ALLOC(ndr, r->driver_name);
5915                 } else {
5916                         r->driver_name = NULL;
5917                 }
5918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5920                 if (_ptr_text_status) {
5921                         NDR_PULL_ALLOC(ndr, r->text_status);
5922                 } else {
5923                         r->text_status = NULL;
5924                 }
5925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5926                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5928                 if (r->priority > 99) {
5929                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5930                 }
5931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5936                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5940                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5941         }
5942         if (ndr_flags & NDR_BUFFERS) {
5943                 if (r->printer_name) {
5944                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5945                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5948                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5949                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5950                         }
5951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5954                 }
5955                 if (r->server_name) {
5956                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5957                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5960                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5961                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5962                         }
5963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5966                 }
5967                 if (r->user_name) {
5968                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5972                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5973                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5978                 }
5979                 if (r->document_name) {
5980                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5981                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5984                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5985                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5986                         }
5987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5990                 }
5991                 if (r->notify_name) {
5992                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5993                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5996                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5997                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5998                         }
5999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6002                 }
6003                 if (r->data_type) {
6004                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6005                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6008                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6009                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
6010                         }
6011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6014                 }
6015                 if (r->print_processor) {
6016                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6017                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6020                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6021                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
6022                         }
6023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6026                 }
6027                 if (r->parameters) {
6028                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6032                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6033                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6034                         }
6035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6038                 }
6039                 if (r->driver_name) {
6040                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6041                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6044                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6045                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
6046                         }
6047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6050                 }
6051                 if (r->text_status) {
6052                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6053                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6056                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6057                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
6058                         }
6059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6062                 }
6063         }
6064         return NDR_ERR_SUCCESS;
6065 }
6066
6067 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6068 {
6069         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6070         ndr->depth++;
6071         ndr_print_uint32(ndr, "job_id", r->job_id);
6072         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6073         ndr->depth++;
6074         if (r->printer_name) {
6075                 ndr_print_string(ndr, "printer_name", r->printer_name);
6076         }
6077         ndr->depth--;
6078         ndr_print_ptr(ndr, "server_name", r->server_name);
6079         ndr->depth++;
6080         if (r->server_name) {
6081                 ndr_print_string(ndr, "server_name", r->server_name);
6082         }
6083         ndr->depth--;
6084         ndr_print_ptr(ndr, "user_name", r->user_name);
6085         ndr->depth++;
6086         if (r->user_name) {
6087                 ndr_print_string(ndr, "user_name", r->user_name);
6088         }
6089         ndr->depth--;
6090         ndr_print_ptr(ndr, "document_name", r->document_name);
6091         ndr->depth++;
6092         if (r->document_name) {
6093                 ndr_print_string(ndr, "document_name", r->document_name);
6094         }
6095         ndr->depth--;
6096         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6097         ndr->depth++;
6098         if (r->notify_name) {
6099                 ndr_print_string(ndr, "notify_name", r->notify_name);
6100         }
6101         ndr->depth--;
6102         ndr_print_ptr(ndr, "data_type", r->data_type);
6103         ndr->depth++;
6104         if (r->data_type) {
6105                 ndr_print_string(ndr, "data_type", r->data_type);
6106         }
6107         ndr->depth--;
6108         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6109         ndr->depth++;
6110         if (r->print_processor) {
6111                 ndr_print_string(ndr, "print_processor", r->print_processor);
6112         }
6113         ndr->depth--;
6114         ndr_print_ptr(ndr, "parameters", r->parameters);
6115         ndr->depth++;
6116         if (r->parameters) {
6117                 ndr_print_string(ndr, "parameters", r->parameters);
6118         }
6119         ndr->depth--;
6120         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6121         ndr->depth++;
6122         if (r->driver_name) {
6123                 ndr_print_string(ndr, "driver_name", r->driver_name);
6124         }
6125         ndr->depth--;
6126         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6127         ndr_print_ptr(ndr, "text_status", r->text_status);
6128         ndr->depth++;
6129         if (r->text_status) {
6130                 ndr_print_string(ndr, "text_status", r->text_status);
6131         }
6132         ndr->depth--;
6133         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6134         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6135         ndr_print_uint32(ndr, "priority", r->priority);
6136         ndr_print_uint32(ndr, "position", r->position);
6137         ndr_print_uint32(ndr, "start_time", r->start_time);
6138         ndr_print_uint32(ndr, "until_time", r->until_time);
6139         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6140         ndr_print_uint32(ndr, "size", r->size);
6141         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6142         ndr_print_uint32(ndr, "time", r->time);
6143         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6144         ndr_print_uint32(ndr, "size_high", r->size_high);
6145         ndr->depth--;
6146 }
6147
6148 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6149 {
6150         if (ndr_flags & NDR_SCALARS) {
6151                 int level = ndr_push_get_switch_value(ndr, r);
6152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6153                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6154                 switch (level) {
6155                         case 1: {
6156                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6157                         break; }
6158
6159                         case 2: {
6160                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6161                         break; }
6162
6163                         case 3: {
6164                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6165                         break; }
6166
6167                         case 4: {
6168                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6169                         break; }
6170
6171                         default: {
6172                         break; }
6173
6174                 }
6175         }
6176         if (ndr_flags & NDR_BUFFERS) {
6177                 int level = ndr_push_get_switch_value(ndr, r);
6178                 switch (level) {
6179                         case 1:
6180                                 if (r->info1) {
6181                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6182                                 }
6183                         break;
6184
6185                         case 2:
6186                                 if (r->info2) {
6187                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6188                                 }
6189                         break;
6190
6191                         case 3:
6192                                 if (r->info3) {
6193                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6194                                 }
6195                         break;
6196
6197                         case 4:
6198                                 if (r->info4) {
6199                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6200                                 }
6201                         break;
6202
6203                         default:
6204                         break;
6205
6206                 }
6207         }
6208         return NDR_ERR_SUCCESS;
6209 }
6210
6211 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6212 {
6213         int level;
6214         uint32_t _level;
6215         TALLOC_CTX *_mem_save_info1_0;
6216         TALLOC_CTX *_mem_save_info2_0;
6217         TALLOC_CTX *_mem_save_info3_0;
6218         TALLOC_CTX *_mem_save_info4_0;
6219         level = ndr_pull_get_switch_value(ndr, r);
6220         if (ndr_flags & NDR_SCALARS) {
6221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6222                 if (_level != level) {
6223                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6224                 }
6225                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6226                 switch (level) {
6227                         case 1: {
6228                                 uint32_t _ptr_info1;
6229                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6230                                 if (_ptr_info1) {
6231                                         NDR_PULL_ALLOC(ndr, r->info1);
6232                                 } else {
6233                                         r->info1 = NULL;
6234                                 }
6235                         break; }
6236
6237                         case 2: {
6238                                 uint32_t _ptr_info2;
6239                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6240                                 if (_ptr_info2) {
6241                                         NDR_PULL_ALLOC(ndr, r->info2);
6242                                 } else {
6243                                         r->info2 = NULL;
6244                                 }
6245                         break; }
6246
6247                         case 3: {
6248                                 uint32_t _ptr_info3;
6249                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6250                                 if (_ptr_info3) {
6251                                         NDR_PULL_ALLOC(ndr, r->info3);
6252                                 } else {
6253                                         r->info3 = NULL;
6254                                 }
6255                         break; }
6256
6257                         case 4: {
6258                                 uint32_t _ptr_info4;
6259                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6260                                 if (_ptr_info4) {
6261                                         NDR_PULL_ALLOC(ndr, r->info4);
6262                                 } else {
6263                                         r->info4 = NULL;
6264                                 }
6265                         break; }
6266
6267                         default: {
6268                         break; }
6269
6270                 }
6271         }
6272         if (ndr_flags & NDR_BUFFERS) {
6273                 switch (level) {
6274                         case 1:
6275                                 if (r->info1) {
6276                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6278                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6279                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6280                                 }
6281                         break;
6282
6283                         case 2:
6284                                 if (r->info2) {
6285                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6286                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6287                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6288                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6289                                 }
6290                         break;
6291
6292                         case 3:
6293                                 if (r->info3) {
6294                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6295                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6296                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6297                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6298                                 }
6299                         break;
6300
6301                         case 4:
6302                                 if (r->info4) {
6303                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6304                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6305                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6306                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6307                                 }
6308                         break;
6309
6310                         default:
6311                         break;
6312
6313                 }
6314         }
6315         return NDR_ERR_SUCCESS;
6316 }
6317
6318 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6319 {
6320         int level;
6321         level = ndr_print_get_switch_value(ndr, r);
6322         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6323         switch (level) {
6324                 case 1:
6325                         ndr_print_ptr(ndr, "info1", r->info1);
6326                         ndr->depth++;
6327                         if (r->info1) {
6328                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6329                         }
6330                         ndr->depth--;
6331                 break;
6332
6333                 case 2:
6334                         ndr_print_ptr(ndr, "info2", r->info2);
6335                         ndr->depth++;
6336                         if (r->info2) {
6337                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6338                         }
6339                         ndr->depth--;
6340                 break;
6341
6342                 case 3:
6343                         ndr_print_ptr(ndr, "info3", r->info3);
6344                         ndr->depth++;
6345                         if (r->info3) {
6346                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6347                         }
6348                         ndr->depth--;
6349                 break;
6350
6351                 case 4:
6352                         ndr_print_ptr(ndr, "info4", r->info4);
6353                         ndr->depth++;
6354                         if (r->info4) {
6355                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6356                         }
6357                         ndr->depth--;
6358                 break;
6359
6360                 default:
6361                 break;
6362
6363         }
6364 }
6365
6366 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6367 {
6368         if (ndr_flags & NDR_SCALARS) {
6369                 NDR_CHECK(ndr_push_align(ndr, 5));
6370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6371                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6372                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6373                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6374         }
6375         if (ndr_flags & NDR_BUFFERS) {
6376                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6377         }
6378         return NDR_ERR_SUCCESS;
6379 }
6380
6381 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6382 {
6383         if (ndr_flags & NDR_SCALARS) {
6384                 NDR_CHECK(ndr_pull_align(ndr, 5));
6385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6386                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6387                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6388                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6389         }
6390         if (ndr_flags & NDR_BUFFERS) {
6391                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6392         }
6393         return NDR_ERR_SUCCESS;
6394 }
6395
6396 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6397 {
6398         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6399         ndr->depth++;
6400         ndr_print_uint32(ndr, "level", r->level);
6401         ndr_print_set_switch_value(ndr, &r->info, r->level);
6402         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6403         ndr->depth--;
6404 }
6405
6406 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6407 {
6408         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6409         return NDR_ERR_SUCCESS;
6410 }
6411
6412 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6413 {
6414         uint32_t v;
6415         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6416         *r = v;
6417         return NDR_ERR_SUCCESS;
6418 }
6419
6420 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6421 {
6422         const char *val = NULL;
6423
6424         switch (r) {
6425                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6426                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6427                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6428                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6429                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6430                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6431                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6432                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6433                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6434         }
6435         ndr_print_enum(ndr, name, "ENUM", val, r);
6436 }
6437
6438 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6439 {
6440         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6441         return NDR_ERR_SUCCESS;
6442 }
6443
6444 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6445 {
6446         uint32_t v;
6447         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6448         *r = v;
6449         return NDR_ERR_SUCCESS;
6450 }
6451
6452 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6453 {
6454         const char *val = NULL;
6455
6456         switch (r) {
6457                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6458                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6459                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6460                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6461                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6462         }
6463         ndr_print_enum(ndr, name, "ENUM", val, r);
6464 }
6465
6466 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6467 {
6468         if (ndr_flags & NDR_SCALARS) {
6469                 NDR_CHECK(ndr_push_align(ndr, 5));
6470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6475                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6487                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6490                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6494                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6499                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6500         }
6501         if (ndr_flags & NDR_BUFFERS) {
6502                 if (r->servername) {
6503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6506                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6507                 }
6508                 if (r->printername) {
6509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6513                 }
6514         }
6515         return NDR_ERR_SUCCESS;
6516 }
6517
6518 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6519 {
6520         uint32_t _ptr_servername;
6521         TALLOC_CTX *_mem_save_servername_0;
6522         uint32_t _ptr_printername;
6523         TALLOC_CTX *_mem_save_printername_0;
6524         if (ndr_flags & NDR_SCALARS) {
6525                 NDR_CHECK(ndr_pull_align(ndr, 5));
6526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6527                 if (_ptr_servername) {
6528                         NDR_PULL_ALLOC(ndr, r->servername);
6529                 } else {
6530                         r->servername = NULL;
6531                 }
6532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6533                 if (_ptr_printername) {
6534                         NDR_PULL_ALLOC(ndr, r->printername);
6535                 } else {
6536                         r->printername = NULL;
6537                 }
6538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6541                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6553                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6560                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6565                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6566         }
6567         if (ndr_flags & NDR_BUFFERS) {
6568                 if (r->servername) {
6569                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6570                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6573                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6575                         }
6576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6579                 }
6580                 if (r->printername) {
6581                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6585                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6586                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6587                         }
6588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6591                 }
6592         }
6593         return NDR_ERR_SUCCESS;
6594 }
6595
6596 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6597 {
6598         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6599         ndr->depth++;
6600         ndr_print_ptr(ndr, "servername", r->servername);
6601         ndr->depth++;
6602         if (r->servername) {
6603                 ndr_print_string(ndr, "servername", r->servername);
6604         }
6605         ndr->depth--;
6606         ndr_print_ptr(ndr, "printername", r->printername);
6607         ndr->depth++;
6608         if (r->printername) {
6609                 ndr_print_string(ndr, "printername", r->printername);
6610         }
6611         ndr->depth--;
6612         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6613         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6614         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6615         ndr_print_spoolss_Time(ndr, "time", &r->time);
6616         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6617         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6618         ndr_print_uint32(ndr, "version", r->version);
6619         ndr_print_uint32(ndr, "free_build", r->free_build);
6620         ndr_print_uint32(ndr, "spooling", r->spooling);
6621         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6622         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6623         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6624         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6625         ndr_print_uint32(ndr, "job_error", r->job_error);
6626         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6627         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6628         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6629         ndr_print_uint32(ndr, "change_id", r->change_id);
6630         ndr_print_WERROR(ndr, "last_error", r->last_error);
6631         ndr_print_uint32(ndr, "status", r->status);
6632         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6633         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6634         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6635         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6636         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6637         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6638         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6639         ndr->depth--;
6640 }
6641
6642 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6643 {
6644         if (ndr_flags & NDR_SCALARS) {
6645                 NDR_CHECK(ndr_push_align(ndr, 5));
6646                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6650                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6651         }
6652         if (ndr_flags & NDR_BUFFERS) {
6653                 if (r->description) {
6654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6658                 }
6659                 if (r->name) {
6660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6664                 }
6665                 if (r->comment) {
6666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6670                 }
6671         }
6672         return NDR_ERR_SUCCESS;
6673 }
6674
6675 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6676 {
6677         uint32_t _ptr_description;
6678         TALLOC_CTX *_mem_save_description_0;
6679         uint32_t _ptr_name;
6680         TALLOC_CTX *_mem_save_name_0;
6681         uint32_t _ptr_comment;
6682         TALLOC_CTX *_mem_save_comment_0;
6683         if (ndr_flags & NDR_SCALARS) {
6684                 NDR_CHECK(ndr_pull_align(ndr, 5));
6685                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6687                 if (_ptr_description) {
6688                         NDR_PULL_ALLOC(ndr, r->description);
6689                 } else {
6690                         r->description = NULL;
6691                 }
6692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6693                 if (_ptr_name) {
6694                         NDR_PULL_ALLOC(ndr, r->name);
6695                 } else {
6696                         r->name = NULL;
6697                 }
6698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6699                 if (_ptr_comment) {
6700                         NDR_PULL_ALLOC(ndr, r->comment);
6701                 } else {
6702                         r->comment = NULL;
6703                 }
6704                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6705         }
6706         if (ndr_flags & NDR_BUFFERS) {
6707                 if (r->description) {
6708                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6709                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6712                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6713                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
6714                         }
6715                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6716                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6718                 }
6719                 if (r->name) {
6720                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6721                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6722                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6723                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6724                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6725                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
6726                         }
6727                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6728                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6730                 }
6731                 if (r->comment) {
6732                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6733                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6734                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6735                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6736                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6737                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6738                         }
6739                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6740                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6742                 }
6743         }
6744         return NDR_ERR_SUCCESS;
6745 }
6746
6747 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6748 {
6749         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6750         ndr->depth++;
6751         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6752         ndr_print_ptr(ndr, "description", r->description);
6753         ndr->depth++;
6754         if (r->description) {
6755                 ndr_print_string(ndr, "description", r->description);
6756         }
6757         ndr->depth--;
6758         ndr_print_ptr(ndr, "name", r->name);
6759         ndr->depth++;
6760         if (r->name) {
6761                 ndr_print_string(ndr, "name", r->name);
6762         }
6763         ndr->depth--;
6764         ndr_print_ptr(ndr, "comment", r->comment);
6765         ndr->depth++;
6766         if (r->comment) {
6767                 ndr_print_string(ndr, "comment", r->comment);
6768         }
6769         ndr->depth--;
6770         ndr->depth--;
6771 }
6772
6773 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6774 {
6775         if (ndr_flags & NDR_SCALARS) {
6776                 NDR_CHECK(ndr_push_align(ndr, 5));
6777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6790                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6795                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6798                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6799         }
6800         if (ndr_flags & NDR_BUFFERS) {
6801                 if (r->servername) {
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6806                 }
6807                 if (r->printername) {
6808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6811                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6812                 }
6813                 if (r->sharename) {
6814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6817                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6818                 }
6819                 if (r->portname) {
6820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6824                 }
6825                 if (r->drivername) {
6826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6830                 }
6831                 if (r->comment) {
6832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6836                 }
6837                 if (r->location) {
6838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6842                 }
6843                 if (r->devmode) {
6844                         {
6845                                 struct ndr_push *_ndr_devmode;
6846                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6847                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6848                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6849                         }
6850                 }
6851                 if (r->sepfile) {
6852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6856                 }
6857                 if (r->printprocessor) {
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6862                 }
6863                 if (r->datatype) {
6864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6868                 }
6869                 if (r->parameters) {
6870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6874                 }
6875                 if (r->secdesc) {
6876                         {
6877                                 struct ndr_push *_ndr_secdesc;
6878                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6879                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6880                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6881                         }
6882                 }
6883         }
6884         return NDR_ERR_SUCCESS;
6885 }
6886
6887 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6888 {
6889         uint32_t _ptr_servername;
6890         TALLOC_CTX *_mem_save_servername_0;
6891         uint32_t _ptr_printername;
6892         TALLOC_CTX *_mem_save_printername_0;
6893         uint32_t _ptr_sharename;
6894         TALLOC_CTX *_mem_save_sharename_0;
6895         uint32_t _ptr_portname;
6896         TALLOC_CTX *_mem_save_portname_0;
6897         uint32_t _ptr_drivername;
6898         TALLOC_CTX *_mem_save_drivername_0;
6899         uint32_t _ptr_comment;
6900         TALLOC_CTX *_mem_save_comment_0;
6901         uint32_t _ptr_location;
6902         TALLOC_CTX *_mem_save_location_0;
6903         uint32_t _ptr_devmode;
6904         TALLOC_CTX *_mem_save_devmode_0;
6905         uint32_t _ptr_sepfile;
6906         TALLOC_CTX *_mem_save_sepfile_0;
6907         uint32_t _ptr_printprocessor;
6908         TALLOC_CTX *_mem_save_printprocessor_0;
6909         uint32_t _ptr_datatype;
6910         TALLOC_CTX *_mem_save_datatype_0;
6911         uint32_t _ptr_parameters;
6912         TALLOC_CTX *_mem_save_parameters_0;
6913         uint32_t _ptr_secdesc;
6914         TALLOC_CTX *_mem_save_secdesc_0;
6915         if (ndr_flags & NDR_SCALARS) {
6916                 NDR_CHECK(ndr_pull_align(ndr, 5));
6917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6918                 if (_ptr_servername) {
6919                         NDR_PULL_ALLOC(ndr, r->servername);
6920                 } else {
6921                         r->servername = NULL;
6922                 }
6923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6924                 if (_ptr_printername) {
6925                         NDR_PULL_ALLOC(ndr, r->printername);
6926                 } else {
6927                         r->printername = NULL;
6928                 }
6929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6930                 if (_ptr_sharename) {
6931                         NDR_PULL_ALLOC(ndr, r->sharename);
6932                 } else {
6933                         r->sharename = NULL;
6934                 }
6935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6936                 if (_ptr_portname) {
6937                         NDR_PULL_ALLOC(ndr, r->portname);
6938                 } else {
6939                         r->portname = NULL;
6940                 }
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6942                 if (_ptr_drivername) {
6943                         NDR_PULL_ALLOC(ndr, r->drivername);
6944                 } else {
6945                         r->drivername = NULL;
6946                 }
6947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6948                 if (_ptr_comment) {
6949                         NDR_PULL_ALLOC(ndr, r->comment);
6950                 } else {
6951                         r->comment = NULL;
6952                 }
6953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6954                 if (_ptr_location) {
6955                         NDR_PULL_ALLOC(ndr, r->location);
6956                 } else {
6957                         r->location = NULL;
6958                 }
6959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6960                 if (_ptr_devmode) {
6961                         NDR_PULL_ALLOC(ndr, r->devmode);
6962                 } else {
6963                         r->devmode = NULL;
6964                 }
6965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6966                 if (_ptr_sepfile) {
6967                         NDR_PULL_ALLOC(ndr, r->sepfile);
6968                 } else {
6969                         r->sepfile = NULL;
6970                 }
6971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6972                 if (_ptr_printprocessor) {
6973                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6974                 } else {
6975                         r->printprocessor = NULL;
6976                 }
6977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6978                 if (_ptr_datatype) {
6979                         NDR_PULL_ALLOC(ndr, r->datatype);
6980                 } else {
6981                         r->datatype = NULL;
6982                 }
6983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6984                 if (_ptr_parameters) {
6985                         NDR_PULL_ALLOC(ndr, r->parameters);
6986                 } else {
6987                         r->parameters = NULL;
6988                 }
6989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6990                 if (_ptr_secdesc) {
6991                         NDR_PULL_ALLOC(ndr, r->secdesc);
6992                 } else {
6993                         r->secdesc = NULL;
6994                 }
6995                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6997                 if (r->priority > 99) {
6998                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6999                 }
7000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7003                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7006                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7007         }
7008         if (ndr_flags & NDR_BUFFERS) {
7009                 if (r->servername) {
7010                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7011                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7014                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
7016                         }
7017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7020                 }
7021                 if (r->printername) {
7022                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7023                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7026                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7027                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7028                         }
7029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7032                 }
7033                 if (r->sharename) {
7034                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7038                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7039                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
7040                         }
7041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7044                 }
7045                 if (r->portname) {
7046                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7047                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7050                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7051                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7052                         }
7053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7056                 }
7057                 if (r->drivername) {
7058                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7062                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7068                 }
7069                 if (r->comment) {
7070                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7071                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7074                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7075                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
7076                         }
7077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7080                 }
7081                 if (r->location) {
7082                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7083                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7086                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7087                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
7088                         }
7089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7092                 }
7093                 if (r->devmode) {
7094                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
7095                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
7096                         {
7097                                 struct ndr_pull *_ndr_devmode;
7098                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
7099                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
7100                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
7101                         }
7102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
7103                 }
7104                 if (r->sepfile) {
7105                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7106                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7109                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7110                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
7111                         }
7112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7115                 }
7116                 if (r->printprocessor) {
7117                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7118                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7121                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7122                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
7123                         }
7124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7127                 }
7128                 if (r->datatype) {
7129                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7130                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7133                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7134                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
7135                         }
7136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7139                 }
7140                 if (r->parameters) {
7141                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7142                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7145                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7146                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
7147                         }
7148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7151                 }
7152                 if (r->secdesc) {
7153                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
7154                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
7155                         {
7156                                 struct ndr_pull *_ndr_secdesc;
7157                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
7158                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
7159                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
7160                         }
7161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
7162                 }
7163         }
7164         return NDR_ERR_SUCCESS;
7165 }
7166
7167 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7168 {
7169         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7170         ndr->depth++;
7171         ndr_print_ptr(ndr, "servername", r->servername);
7172         ndr->depth++;
7173         if (r->servername) {
7174                 ndr_print_string(ndr, "servername", r->servername);
7175         }
7176         ndr->depth--;
7177         ndr_print_ptr(ndr, "printername", r->printername);
7178         ndr->depth++;
7179         if (r->printername) {
7180                 ndr_print_string(ndr, "printername", r->printername);
7181         }
7182         ndr->depth--;
7183         ndr_print_ptr(ndr, "sharename", r->sharename);
7184         ndr->depth++;
7185         if (r->sharename) {
7186                 ndr_print_string(ndr, "sharename", r->sharename);
7187         }
7188         ndr->depth--;
7189         ndr_print_ptr(ndr, "portname", r->portname);
7190         ndr->depth++;
7191         if (r->portname) {
7192                 ndr_print_string(ndr, "portname", r->portname);
7193         }
7194         ndr->depth--;
7195         ndr_print_ptr(ndr, "drivername", r->drivername);
7196         ndr->depth++;
7197         if (r->drivername) {
7198                 ndr_print_string(ndr, "drivername", r->drivername);
7199         }
7200         ndr->depth--;
7201         ndr_print_ptr(ndr, "comment", r->comment);
7202         ndr->depth++;
7203         if (r->comment) {
7204                 ndr_print_string(ndr, "comment", r->comment);
7205         }
7206         ndr->depth--;
7207         ndr_print_ptr(ndr, "location", r->location);
7208         ndr->depth++;
7209         if (r->location) {
7210                 ndr_print_string(ndr, "location", r->location);
7211         }
7212         ndr->depth--;
7213         ndr_print_ptr(ndr, "devmode", r->devmode);
7214         ndr->depth++;
7215         if (r->devmode) {
7216                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
7217         }
7218         ndr->depth--;
7219         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7220         ndr->depth++;
7221         if (r->sepfile) {
7222                 ndr_print_string(ndr, "sepfile", r->sepfile);
7223         }
7224         ndr->depth--;
7225         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7226         ndr->depth++;
7227         if (r->printprocessor) {
7228                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7229         }
7230         ndr->depth--;
7231         ndr_print_ptr(ndr, "datatype", r->datatype);
7232         ndr->depth++;
7233         if (r->datatype) {
7234                 ndr_print_string(ndr, "datatype", r->datatype);
7235         }
7236         ndr->depth--;
7237         ndr_print_ptr(ndr, "parameters", r->parameters);
7238         ndr->depth++;
7239         if (r->parameters) {
7240                 ndr_print_string(ndr, "parameters", r->parameters);
7241         }
7242         ndr->depth--;
7243         ndr_print_ptr(ndr, "secdesc", r->secdesc);
7244         ndr->depth++;
7245         if (r->secdesc) {
7246                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
7247         }
7248         ndr->depth--;
7249         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7250         ndr_print_uint32(ndr, "priority", r->priority);
7251         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7252         ndr_print_uint32(ndr, "starttime", r->starttime);
7253         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7254         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7255         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7256         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7257         ndr->depth--;
7258 }
7259
7260 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7261 {
7262         if (ndr_flags & NDR_SCALARS) {
7263                 NDR_CHECK(ndr_push_align(ndr, 4));
7264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7265                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7266         }
7267         if (ndr_flags & NDR_BUFFERS) {
7268         }
7269         return NDR_ERR_SUCCESS;
7270 }
7271
7272 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7273 {
7274         if (ndr_flags & NDR_SCALARS) {
7275                 NDR_CHECK(ndr_pull_align(ndr, 4));
7276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7277                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7278         }
7279         if (ndr_flags & NDR_BUFFERS) {
7280         }
7281         return NDR_ERR_SUCCESS;
7282 }
7283
7284 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7285 {
7286         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7287         ndr->depth++;
7288         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7289         ndr->depth--;
7290 }
7291
7292 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7293 {
7294         if (ndr_flags & NDR_SCALARS) {
7295                 NDR_CHECK(ndr_push_align(ndr, 5));
7296                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7298                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7299                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7300         }
7301         if (ndr_flags & NDR_BUFFERS) {
7302                 if (r->printername) {
7303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7307                 }
7308                 if (r->servername) {
7309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7312                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7313                 }
7314         }
7315         return NDR_ERR_SUCCESS;
7316 }
7317
7318 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7319 {
7320         uint32_t _ptr_printername;
7321         TALLOC_CTX *_mem_save_printername_0;
7322         uint32_t _ptr_servername;
7323         TALLOC_CTX *_mem_save_servername_0;
7324         if (ndr_flags & NDR_SCALARS) {
7325                 NDR_CHECK(ndr_pull_align(ndr, 5));
7326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7327                 if (_ptr_printername) {
7328                         NDR_PULL_ALLOC(ndr, r->printername);
7329                 } else {
7330                         r->printername = NULL;
7331                 }
7332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7333                 if (_ptr_servername) {
7334                         NDR_PULL_ALLOC(ndr, r->servername);
7335                 } else {
7336                         r->servername = NULL;
7337                 }
7338                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7339                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342                 if (r->printername) {
7343                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7344                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7347                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7353                 }
7354                 if (r->servername) {
7355                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7356                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7357                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7358                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7359                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7360                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
7361                         }
7362                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7363                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7365                 }
7366         }
7367         return NDR_ERR_SUCCESS;
7368 }
7369
7370 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7371 {
7372         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7373         ndr->depth++;
7374         ndr_print_ptr(ndr, "printername", r->printername);
7375         ndr->depth++;
7376         if (r->printername) {
7377                 ndr_print_string(ndr, "printername", r->printername);
7378         }
7379         ndr->depth--;
7380         ndr_print_ptr(ndr, "servername", r->servername);
7381         ndr->depth++;
7382         if (r->servername) {
7383                 ndr_print_string(ndr, "servername", r->servername);
7384         }
7385         ndr->depth--;
7386         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7387         ndr->depth--;
7388 }
7389
7390 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7391 {
7392         if (ndr_flags & NDR_SCALARS) {
7393                 NDR_CHECK(ndr_push_align(ndr, 5));
7394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7396                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7399                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7400         }
7401         if (ndr_flags & NDR_BUFFERS) {
7402                 if (r->printername) {
7403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7407                 }
7408                 if (r->portname) {
7409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7413                 }
7414         }
7415         return NDR_ERR_SUCCESS;
7416 }
7417
7418 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7419 {
7420         uint32_t _ptr_printername;
7421         TALLOC_CTX *_mem_save_printername_0;
7422         uint32_t _ptr_portname;
7423         TALLOC_CTX *_mem_save_portname_0;
7424         if (ndr_flags & NDR_SCALARS) {
7425                 NDR_CHECK(ndr_pull_align(ndr, 5));
7426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7427                 if (_ptr_printername) {
7428                         NDR_PULL_ALLOC(ndr, r->printername);
7429                 } else {
7430                         r->printername = NULL;
7431                 }
7432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7433                 if (_ptr_portname) {
7434                         NDR_PULL_ALLOC(ndr, r->portname);
7435                 } else {
7436                         r->portname = NULL;
7437                 }
7438                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7441                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7442         }
7443         if (ndr_flags & NDR_BUFFERS) {
7444                 if (r->printername) {
7445                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7446                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7449                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7450                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7451                         }
7452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7455                 }
7456                 if (r->portname) {
7457                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7458                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7459                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7460                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7461                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7462                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7463                         }
7464                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7465                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7467                 }
7468         }
7469         return NDR_ERR_SUCCESS;
7470 }
7471
7472 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7473 {
7474         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7475         ndr->depth++;
7476         ndr_print_ptr(ndr, "printername", r->printername);
7477         ndr->depth++;
7478         if (r->printername) {
7479                 ndr_print_string(ndr, "printername", r->printername);
7480         }
7481         ndr->depth--;
7482         ndr_print_ptr(ndr, "portname", r->portname);
7483         ndr->depth++;
7484         if (r->portname) {
7485                 ndr_print_string(ndr, "portname", r->portname);
7486         }
7487         ndr->depth--;
7488         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7489         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7490         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7491         ndr->depth--;
7492 }
7493
7494 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7495 {
7496         if (ndr_flags & NDR_SCALARS) {
7497                 NDR_CHECK(ndr_push_align(ndr, 4));
7498                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7499                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7500         }
7501         if (ndr_flags & NDR_BUFFERS) {
7502         }
7503         return NDR_ERR_SUCCESS;
7504 }
7505
7506 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7507 {
7508         if (ndr_flags & NDR_SCALARS) {
7509                 NDR_CHECK(ndr_pull_align(ndr, 4));
7510                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7512         }
7513         if (ndr_flags & NDR_BUFFERS) {
7514         }
7515         return NDR_ERR_SUCCESS;
7516 }
7517
7518 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7519 {
7520         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7521         ndr->depth++;
7522         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7523         ndr->depth--;
7524 }
7525
7526 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7527 {
7528         if (ndr_flags & NDR_SCALARS) {
7529                 NDR_CHECK(ndr_push_align(ndr, 5));
7530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7531                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7532                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7533         }
7534         if (ndr_flags & NDR_BUFFERS) {
7535                 if (r->guid) {
7536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7538                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7540                 }
7541         }
7542         return NDR_ERR_SUCCESS;
7543 }
7544
7545 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7546 {
7547         uint32_t _ptr_guid;
7548         TALLOC_CTX *_mem_save_guid_0;
7549         if (ndr_flags & NDR_SCALARS) {
7550                 NDR_CHECK(ndr_pull_align(ndr, 5));
7551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7552                 if (_ptr_guid) {
7553                         NDR_PULL_ALLOC(ndr, r->guid);
7554                 } else {
7555                         r->guid = NULL;
7556                 }
7557                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7558                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7559         }
7560         if (ndr_flags & NDR_BUFFERS) {
7561                 if (r->guid) {
7562                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7563                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7566                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
7568                         }
7569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7572                 }
7573         }
7574         return NDR_ERR_SUCCESS;
7575 }
7576
7577 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7578 {
7579         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7580         ndr->depth++;
7581         ndr_print_ptr(ndr, "guid", r->guid);
7582         ndr->depth++;
7583         if (r->guid) {
7584                 ndr_print_string(ndr, "guid", r->guid);
7585         }
7586         ndr->depth--;
7587         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7588         ndr->depth--;
7589 }
7590
7591 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7592 {
7593         if (ndr_flags & NDR_SCALARS) {
7594                 int level = ndr_push_get_switch_value(ndr, r);
7595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7596                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7597                 switch (level) {
7598                         case 0: {
7599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7600                         break; }
7601
7602                         case 1: {
7603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7604                         break; }
7605
7606                         case 2: {
7607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7608                         break; }
7609
7610                         case 3: {
7611                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7612                         break; }
7613
7614                         case 4: {
7615                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7616                         break; }
7617
7618                         case 5: {
7619                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7620                         break; }
7621
7622                         case 6: {
7623                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7624                         break; }
7625
7626                         case 7: {
7627                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7628                         break; }
7629
7630                         case 8: {
7631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7632                         break; }
7633
7634                         case 9: {
7635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7636                         break; }
7637
7638                         default: {
7639                         break; }
7640
7641                 }
7642         }
7643         if (ndr_flags & NDR_BUFFERS) {
7644                 int level = ndr_push_get_switch_value(ndr, r);
7645                 switch (level) {
7646                         case 0:
7647                                 if (r->info0) {
7648                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7649                                 }
7650                         break;
7651
7652                         case 1:
7653                                 if (r->info1) {
7654                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7655                                 }
7656                         break;
7657
7658                         case 2:
7659                                 if (r->info2) {
7660                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7661                                 }
7662                         break;
7663
7664                         case 3:
7665                                 if (r->info3) {
7666                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7667                                 }
7668                         break;
7669
7670                         case 4:
7671                                 if (r->info4) {
7672                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7673                                 }
7674                         break;
7675
7676                         case 5:
7677                                 if (r->info5) {
7678                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7679                                 }
7680                         break;
7681
7682                         case 6:
7683                                 if (r->info6) {
7684                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7685                                 }
7686                         break;
7687
7688                         case 7:
7689                                 if (r->info7) {
7690                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7691                                 }
7692                         break;
7693
7694                         case 8:
7695                                 if (r->info8) {
7696                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7697                                 }
7698                         break;
7699
7700                         case 9:
7701                                 if (r->info9) {
7702                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7703                                 }
7704                         break;
7705
7706                         default:
7707                         break;
7708
7709                 }
7710         }
7711         return NDR_ERR_SUCCESS;
7712 }
7713
7714 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7715 {
7716         int level;
7717         uint32_t _level;
7718         TALLOC_CTX *_mem_save_info0_0;
7719         TALLOC_CTX *_mem_save_info1_0;
7720         TALLOC_CTX *_mem_save_info2_0;
7721         TALLOC_CTX *_mem_save_info3_0;
7722         TALLOC_CTX *_mem_save_info4_0;
7723         TALLOC_CTX *_mem_save_info5_0;
7724         TALLOC_CTX *_mem_save_info6_0;
7725         TALLOC_CTX *_mem_save_info7_0;
7726         TALLOC_CTX *_mem_save_info8_0;
7727         TALLOC_CTX *_mem_save_info9_0;
7728         level = ndr_pull_get_switch_value(ndr, r);
7729         if (ndr_flags & NDR_SCALARS) {
7730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7731                 if (_level != level) {
7732                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7733                 }
7734                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7735                 switch (level) {
7736                         case 0: {
7737                                 uint32_t _ptr_info0;
7738                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7739                                 if (_ptr_info0) {
7740                                         NDR_PULL_ALLOC(ndr, r->info0);
7741                                 } else {
7742                                         r->info0 = NULL;
7743                                 }
7744                         break; }
7745
7746                         case 1: {
7747                                 uint32_t _ptr_info1;
7748                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7749                                 if (_ptr_info1) {
7750                                         NDR_PULL_ALLOC(ndr, r->info1);
7751                                 } else {
7752                                         r->info1 = NULL;
7753                                 }
7754                         break; }
7755
7756                         case 2: {
7757                                 uint32_t _ptr_info2;
7758                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7759                                 if (_ptr_info2) {
7760                                         NDR_PULL_ALLOC(ndr, r->info2);
7761                                 } else {
7762                                         r->info2 = NULL;
7763                                 }
7764                         break; }
7765
7766                         case 3: {
7767                                 uint32_t _ptr_info3;
7768                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7769                                 if (_ptr_info3) {
7770                                         NDR_PULL_ALLOC(ndr, r->info3);
7771                                 } else {
7772                                         r->info3 = NULL;
7773                                 }
7774                         break; }
7775
7776                         case 4: {
7777                                 uint32_t _ptr_info4;
7778                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7779                                 if (_ptr_info4) {
7780                                         NDR_PULL_ALLOC(ndr, r->info4);
7781                                 } else {
7782                                         r->info4 = NULL;
7783                                 }
7784                         break; }
7785
7786                         case 5: {
7787                                 uint32_t _ptr_info5;
7788                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7789                                 if (_ptr_info5) {
7790                                         NDR_PULL_ALLOC(ndr, r->info5);
7791                                 } else {
7792                                         r->info5 = NULL;
7793                                 }
7794                         break; }
7795
7796                         case 6: {
7797                                 uint32_t _ptr_info6;
7798                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7799                                 if (_ptr_info6) {
7800                                         NDR_PULL_ALLOC(ndr, r->info6);
7801                                 } else {
7802                                         r->info6 = NULL;
7803                                 }
7804                         break; }
7805
7806                         case 7: {
7807                                 uint32_t _ptr_info7;
7808                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7809                                 if (_ptr_info7) {
7810                                         NDR_PULL_ALLOC(ndr, r->info7);
7811                                 } else {
7812                                         r->info7 = NULL;
7813                                 }
7814                         break; }
7815
7816                         case 8: {
7817                                 uint32_t _ptr_info8;
7818                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7819                                 if (_ptr_info8) {
7820                                         NDR_PULL_ALLOC(ndr, r->info8);
7821                                 } else {
7822                                         r->info8 = NULL;
7823                                 }
7824                         break; }
7825
7826                         case 9: {
7827                                 uint32_t _ptr_info9;
7828                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7829                                 if (_ptr_info9) {
7830                                         NDR_PULL_ALLOC(ndr, r->info9);
7831                                 } else {
7832                                         r->info9 = NULL;
7833                                 }
7834                         break; }
7835
7836                         default: {
7837                         break; }
7838
7839                 }
7840         }
7841         if (ndr_flags & NDR_BUFFERS) {
7842                 switch (level) {
7843                         case 0:
7844                                 if (r->info0) {
7845                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7846                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7847                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7848                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7849                                 }
7850                         break;
7851
7852                         case 1:
7853                                 if (r->info1) {
7854                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7855                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7856                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7857                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7858                                 }
7859                         break;
7860
7861                         case 2:
7862                                 if (r->info2) {
7863                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7864                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7865                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7866                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7867                                 }
7868                         break;
7869
7870                         case 3:
7871                                 if (r->info3) {
7872                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7873                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7874                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7875                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7876                                 }
7877                         break;
7878
7879                         case 4:
7880                                 if (r->info4) {
7881                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7882                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7883                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7884                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7885                                 }
7886                         break;
7887
7888                         case 5:
7889                                 if (r->info5) {
7890                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7891                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7892                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7893                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7894                                 }
7895                         break;
7896
7897                         case 6:
7898                                 if (r->info6) {
7899                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7900                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7901                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7902                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7903                                 }
7904                         break;
7905
7906                         case 7:
7907                                 if (r->info7) {
7908                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7909                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7910                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7911                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7912                                 }
7913                         break;
7914
7915                         case 8:
7916                                 if (r->info8) {
7917                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7918                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7919                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7920                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7921                                 }
7922                         break;
7923
7924                         case 9:
7925                                 if (r->info9) {
7926                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7927                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7928                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7929                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7930                                 }
7931                         break;
7932
7933                         default:
7934                         break;
7935
7936                 }
7937         }
7938         return NDR_ERR_SUCCESS;
7939 }
7940
7941 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7942 {
7943         int level;
7944         level = ndr_print_get_switch_value(ndr, r);
7945         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7946         switch (level) {
7947                 case 0:
7948                         ndr_print_ptr(ndr, "info0", r->info0);
7949                         ndr->depth++;
7950                         if (r->info0) {
7951                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7952                         }
7953                         ndr->depth--;
7954                 break;
7955
7956                 case 1:
7957                         ndr_print_ptr(ndr, "info1", r->info1);
7958                         ndr->depth++;
7959                         if (r->info1) {
7960                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7961                         }
7962                         ndr->depth--;
7963                 break;
7964
7965                 case 2:
7966                         ndr_print_ptr(ndr, "info2", r->info2);
7967                         ndr->depth++;
7968                         if (r->info2) {
7969                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7970                         }
7971                         ndr->depth--;
7972                 break;
7973
7974                 case 3:
7975                         ndr_print_ptr(ndr, "info3", r->info3);
7976                         ndr->depth++;
7977                         if (r->info3) {
7978                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7979                         }
7980                         ndr->depth--;
7981                 break;
7982
7983                 case 4:
7984                         ndr_print_ptr(ndr, "info4", r->info4);
7985                         ndr->depth++;
7986                         if (r->info4) {
7987                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7988                         }
7989                         ndr->depth--;
7990                 break;
7991
7992                 case 5:
7993                         ndr_print_ptr(ndr, "info5", r->info5);
7994                         ndr->depth++;
7995                         if (r->info5) {
7996                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7997                         }
7998                         ndr->depth--;
7999                 break;
8000
8001                 case 6:
8002                         ndr_print_ptr(ndr, "info6", r->info6);
8003                         ndr->depth++;
8004                         if (r->info6) {
8005                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8006                         }
8007                         ndr->depth--;
8008                 break;
8009
8010                 case 7:
8011                         ndr_print_ptr(ndr, "info7", r->info7);
8012                         ndr->depth++;
8013                         if (r->info7) {
8014                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8015                         }
8016                         ndr->depth--;
8017                 break;
8018
8019                 case 8:
8020                         ndr_print_ptr(ndr, "info8", r->info8);
8021                         ndr->depth++;
8022                         if (r->info8) {
8023                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
8024                         }
8025                         ndr->depth--;
8026                 break;
8027
8028                 case 9:
8029                         ndr_print_ptr(ndr, "info9", r->info9);
8030                         ndr->depth++;
8031                         if (r->info9) {
8032                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
8033                         }
8034                         ndr->depth--;
8035                 break;
8036
8037                 default:
8038                 break;
8039
8040         }
8041 }
8042
8043 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8044 {
8045         if (ndr_flags & NDR_SCALARS) {
8046                 NDR_CHECK(ndr_push_align(ndr, 5));
8047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8048                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8049                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8050                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8051         }
8052         if (ndr_flags & NDR_BUFFERS) {
8053                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8054         }
8055         return NDR_ERR_SUCCESS;
8056 }
8057
8058 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8059 {
8060         if (ndr_flags & NDR_SCALARS) {
8061                 NDR_CHECK(ndr_pull_align(ndr, 5));
8062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8063                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8064                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8065                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8066         }
8067         if (ndr_flags & NDR_BUFFERS) {
8068                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8069         }
8070         return NDR_ERR_SUCCESS;
8071 }
8072
8073 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8074 {
8075         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8076         ndr->depth++;
8077         ndr_print_uint32(ndr, "level", r->level);
8078         ndr_print_set_switch_value(ndr, &r->info, r->level);
8079         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8080         ndr->depth--;
8081 }
8082
8083 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8084 {
8085         if (ndr_flags & NDR_SCALARS) {
8086                 NDR_CHECK(ndr_push_align(ndr, 4));
8087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8088                 {
8089                         uint32_t _flags_save_string_array = ndr->flags;
8090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8091                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8092                         ndr->flags = _flags_save_string_array;
8093                 }
8094                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8095         }
8096         if (ndr_flags & NDR_BUFFERS) {
8097         }
8098         return NDR_ERR_SUCCESS;
8099 }
8100
8101 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8102 {
8103         if (ndr_flags & NDR_SCALARS) {
8104                 NDR_CHECK(ndr_pull_align(ndr, 4));
8105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8106                 {
8107                         uint32_t _flags_save_string_array = ndr->flags;
8108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8109                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8110                         ndr->flags = _flags_save_string_array;
8111                 }
8112                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8113         }
8114         if (ndr_flags & NDR_BUFFERS) {
8115         }
8116         return NDR_ERR_SUCCESS;
8117 }
8118
8119 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8120 {
8121         ndr_print_struct(ndr, name, "spoolss_StringArray");
8122         ndr->depth++;
8123         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
8124         ndr_print_string_array(ndr, "string", r->string);
8125         ndr->depth--;
8126 }
8127
8128 _PUBLIC_ void ndr_print_spoolss_StringArray2(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray2 *r)
8129 {
8130         ndr_print_struct(ndr, name, "spoolss_StringArray2");
8131         ndr->depth++;
8132         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray2(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
8133         ndr_print_string_array(ndr, "string", r->string);
8134         ndr->depth--;
8135 }
8136
8137 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8138 {
8139         if (ndr_flags & NDR_SCALARS) {
8140                 NDR_CHECK(ndr_push_align(ndr, 5));
8141                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8142                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8143         }
8144         if (ndr_flags & NDR_BUFFERS) {
8145                 if (r->driver_name) {
8146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8147                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8149                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8150                 }
8151         }
8152         return NDR_ERR_SUCCESS;
8153 }
8154
8155 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8156 {
8157         uint32_t _ptr_driver_name;
8158         TALLOC_CTX *_mem_save_driver_name_0;
8159         if (ndr_flags & NDR_SCALARS) {
8160                 NDR_CHECK(ndr_pull_align(ndr, 5));
8161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8162                 if (_ptr_driver_name) {
8163                         NDR_PULL_ALLOC(ndr, r->driver_name);
8164                 } else {
8165                         r->driver_name = NULL;
8166                 }
8167                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8168         }
8169         if (ndr_flags & NDR_BUFFERS) {
8170                 if (r->driver_name) {
8171                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8172                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8175                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8176                                 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));
8177                         }
8178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8181                 }
8182         }
8183         return NDR_ERR_SUCCESS;
8184 }
8185
8186 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8187 {
8188         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8189         ndr->depth++;
8190         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8191         ndr->depth++;
8192         if (r->driver_name) {
8193                 ndr_print_string(ndr, "driver_name", r->driver_name);
8194         }
8195         ndr->depth--;
8196         ndr->depth--;
8197 }
8198
8199 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8200 {
8201         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8202         return NDR_ERR_SUCCESS;
8203 }
8204
8205 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8206 {
8207         uint32_t v;
8208         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8209         *r = v;
8210         return NDR_ERR_SUCCESS;
8211 }
8212
8213 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8214 {
8215         const char *val = NULL;
8216
8217         switch (r) {
8218                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8219                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8220                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8221                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8222         }
8223         ndr_print_enum(ndr, name, "ENUM", val, r);
8224 }
8225
8226 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8227 {
8228         if (ndr_flags & NDR_SCALARS) {
8229                 NDR_CHECK(ndr_push_align(ndr, 5));
8230                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8236                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8237         }
8238         if (ndr_flags & NDR_BUFFERS) {
8239                 if (r->driver_name) {
8240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8242                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8243                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8244                 }
8245                 if (r->architecture) {
8246                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8250                 }
8251                 if (r->driver_path) {
8252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8255                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8256                 }
8257                 if (r->data_file) {
8258                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8259                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8261                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8262                 }
8263                 if (r->config_file) {
8264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8265                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8266                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8267                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8268                 }
8269         }
8270         return NDR_ERR_SUCCESS;
8271 }
8272
8273 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8274 {
8275         uint32_t _ptr_driver_name;
8276         TALLOC_CTX *_mem_save_driver_name_0;
8277         uint32_t _ptr_architecture;
8278         TALLOC_CTX *_mem_save_architecture_0;
8279         uint32_t _ptr_driver_path;
8280         TALLOC_CTX *_mem_save_driver_path_0;
8281         uint32_t _ptr_data_file;
8282         TALLOC_CTX *_mem_save_data_file_0;
8283         uint32_t _ptr_config_file;
8284         TALLOC_CTX *_mem_save_config_file_0;
8285         if (ndr_flags & NDR_SCALARS) {
8286                 NDR_CHECK(ndr_pull_align(ndr, 5));
8287                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8289                 if (_ptr_driver_name) {
8290                         NDR_PULL_ALLOC(ndr, r->driver_name);
8291                 } else {
8292                         r->driver_name = NULL;
8293                 }
8294                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8295                 if (_ptr_architecture) {
8296                         NDR_PULL_ALLOC(ndr, r->architecture);
8297                 } else {
8298                         r->architecture = NULL;
8299                 }
8300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8301                 if (_ptr_driver_path) {
8302                         NDR_PULL_ALLOC(ndr, r->driver_path);
8303                 } else {
8304                         r->driver_path = NULL;
8305                 }
8306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8307                 if (_ptr_data_file) {
8308                         NDR_PULL_ALLOC(ndr, r->data_file);
8309                 } else {
8310                         r->data_file = NULL;
8311                 }
8312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8313                 if (_ptr_config_file) {
8314                         NDR_PULL_ALLOC(ndr, r->config_file);
8315                 } else {
8316                         r->config_file = NULL;
8317                 }
8318                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8319         }
8320         if (ndr_flags & NDR_BUFFERS) {
8321                 if (r->driver_name) {
8322                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8323                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8326                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8327                                 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));
8328                         }
8329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8330                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8332                 }
8333                 if (r->architecture) {
8334                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8335                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8338                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8339                                 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));
8340                         }
8341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8344                 }
8345                 if (r->driver_path) {
8346                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8347                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8350                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8351                                 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));
8352                         }
8353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8356                 }
8357                 if (r->data_file) {
8358                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8359                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8362                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8363                                 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));
8364                         }
8365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8368                 }
8369                 if (r->config_file) {
8370                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8371                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8374                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8375                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8376                         }
8377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8380                 }
8381         }
8382         return NDR_ERR_SUCCESS;
8383 }
8384
8385 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8386 {
8387         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8388         ndr->depth++;
8389         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8390         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8391         ndr->depth++;
8392         if (r->driver_name) {
8393                 ndr_print_string(ndr, "driver_name", r->driver_name);
8394         }
8395         ndr->depth--;
8396         ndr_print_ptr(ndr, "architecture", r->architecture);
8397         ndr->depth++;
8398         if (r->architecture) {
8399                 ndr_print_string(ndr, "architecture", r->architecture);
8400         }
8401         ndr->depth--;
8402         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8403         ndr->depth++;
8404         if (r->driver_path) {
8405                 ndr_print_string(ndr, "driver_path", r->driver_path);
8406         }
8407         ndr->depth--;
8408         ndr_print_ptr(ndr, "data_file", r->data_file);
8409         ndr->depth++;
8410         if (r->data_file) {
8411                 ndr_print_string(ndr, "data_file", r->data_file);
8412         }
8413         ndr->depth--;
8414         ndr_print_ptr(ndr, "config_file", r->config_file);
8415         ndr->depth++;
8416         if (r->config_file) {
8417                 ndr_print_string(ndr, "config_file", r->config_file);
8418         }
8419         ndr->depth--;
8420         ndr->depth--;
8421 }
8422
8423 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8424 {
8425         if (ndr_flags & NDR_SCALARS) {
8426                 NDR_CHECK(ndr_push_align(ndr, 5));
8427                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8431                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8435                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8438                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8439         }
8440         if (ndr_flags & NDR_BUFFERS) {
8441                 if (r->driver_name) {
8442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8444                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8446                 }
8447                 if (r->architecture) {
8448                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8452                 }
8453                 if (r->driver_path) {
8454                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8457                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8458                 }
8459                 if (r->data_file) {
8460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8461                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8462                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8463                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8464                 }
8465                 if (r->config_file) {
8466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8469                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8470                 }
8471                 if (r->help_file) {
8472                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8475                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8476                 }
8477                 if (r->monitor_name) {
8478                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8480                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8481                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8482                 }
8483                 if (r->default_datatype) {
8484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8486                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8487                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8488                 }
8489                 if (r->dependent_files) {
8490                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8491                 }
8492         }
8493         return NDR_ERR_SUCCESS;
8494 }
8495
8496 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8497 {
8498         uint32_t _ptr_driver_name;
8499         TALLOC_CTX *_mem_save_driver_name_0;
8500         uint32_t _ptr_architecture;
8501         TALLOC_CTX *_mem_save_architecture_0;
8502         uint32_t _ptr_driver_path;
8503         TALLOC_CTX *_mem_save_driver_path_0;
8504         uint32_t _ptr_data_file;
8505         TALLOC_CTX *_mem_save_data_file_0;
8506         uint32_t _ptr_config_file;
8507         TALLOC_CTX *_mem_save_config_file_0;
8508         uint32_t _ptr_help_file;
8509         TALLOC_CTX *_mem_save_help_file_0;
8510         uint32_t _ptr_monitor_name;
8511         TALLOC_CTX *_mem_save_monitor_name_0;
8512         uint32_t _ptr_default_datatype;
8513         TALLOC_CTX *_mem_save_default_datatype_0;
8514         uint32_t _ptr_dependent_files;
8515         TALLOC_CTX *_mem_save_dependent_files_0;
8516         if (ndr_flags & NDR_SCALARS) {
8517                 NDR_CHECK(ndr_pull_align(ndr, 5));
8518                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8520                 if (_ptr_driver_name) {
8521                         NDR_PULL_ALLOC(ndr, r->driver_name);
8522                 } else {
8523                         r->driver_name = NULL;
8524                 }
8525                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8526                 if (_ptr_architecture) {
8527                         NDR_PULL_ALLOC(ndr, r->architecture);
8528                 } else {
8529                         r->architecture = NULL;
8530                 }
8531                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8532                 if (_ptr_driver_path) {
8533                         NDR_PULL_ALLOC(ndr, r->driver_path);
8534                 } else {
8535                         r->driver_path = NULL;
8536                 }
8537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8538                 if (_ptr_data_file) {
8539                         NDR_PULL_ALLOC(ndr, r->data_file);
8540                 } else {
8541                         r->data_file = NULL;
8542                 }
8543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8544                 if (_ptr_config_file) {
8545                         NDR_PULL_ALLOC(ndr, r->config_file);
8546                 } else {
8547                         r->config_file = NULL;
8548                 }
8549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8550                 if (_ptr_help_file) {
8551                         NDR_PULL_ALLOC(ndr, r->help_file);
8552                 } else {
8553                         r->help_file = NULL;
8554                 }
8555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8556                 if (_ptr_monitor_name) {
8557                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8558                 } else {
8559                         r->monitor_name = NULL;
8560                 }
8561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8562                 if (_ptr_default_datatype) {
8563                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8564                 } else {
8565                         r->default_datatype = NULL;
8566                 }
8567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8569                 if (_ptr_dependent_files) {
8570                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8571                 } else {
8572                         r->dependent_files = NULL;
8573                 }
8574                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8575         }
8576         if (ndr_flags & NDR_BUFFERS) {
8577                 if (r->driver_name) {
8578                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8579                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8580                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8581                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8582                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8583                                 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));
8584                         }
8585                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8586                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8587                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8588                 }
8589                 if (r->architecture) {
8590                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8591                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8592                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8593                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8594                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8595                                 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));
8596                         }
8597                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8598                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8600                 }
8601                 if (r->driver_path) {
8602                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8603                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8604                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8605                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8606                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8607                                 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));
8608                         }
8609                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8610                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8612                 }
8613                 if (r->data_file) {
8614                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8615                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8617                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8618                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8619                                 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));
8620                         }
8621                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8622                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8624                 }
8625                 if (r->config_file) {
8626                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8627                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8629                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8630                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8631                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8632                         }
8633                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8634                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8636                 }
8637                 if (r->help_file) {
8638                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8639                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8640                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8641                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8642                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8643                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8644                         }
8645                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8646                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8648                 }
8649                 if (r->monitor_name) {
8650                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8651                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8654                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8655                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8656                         }
8657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8658                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8660                 }
8661                 if (r->default_datatype) {
8662                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8663                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8666                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8667                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8668                         }
8669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8672                 }
8673                 if (r->dependent_files) {
8674                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8675                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8676                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8678                 }
8679         }
8680         return NDR_ERR_SUCCESS;
8681 }
8682
8683 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8684 {
8685         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8686         ndr->depth++;
8687         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8688         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8689         ndr->depth++;
8690         if (r->driver_name) {
8691                 ndr_print_string(ndr, "driver_name", r->driver_name);
8692         }
8693         ndr->depth--;
8694         ndr_print_ptr(ndr, "architecture", r->architecture);
8695         ndr->depth++;
8696         if (r->architecture) {
8697                 ndr_print_string(ndr, "architecture", r->architecture);
8698         }
8699         ndr->depth--;
8700         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8701         ndr->depth++;
8702         if (r->driver_path) {
8703                 ndr_print_string(ndr, "driver_path", r->driver_path);
8704         }
8705         ndr->depth--;
8706         ndr_print_ptr(ndr, "data_file", r->data_file);
8707         ndr->depth++;
8708         if (r->data_file) {
8709                 ndr_print_string(ndr, "data_file", r->data_file);
8710         }
8711         ndr->depth--;
8712         ndr_print_ptr(ndr, "config_file", r->config_file);
8713         ndr->depth++;
8714         if (r->config_file) {
8715                 ndr_print_string(ndr, "config_file", r->config_file);
8716         }
8717         ndr->depth--;
8718         ndr_print_ptr(ndr, "help_file", r->help_file);
8719         ndr->depth++;
8720         if (r->help_file) {
8721                 ndr_print_string(ndr, "help_file", r->help_file);
8722         }
8723         ndr->depth--;
8724         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8725         ndr->depth++;
8726         if (r->monitor_name) {
8727                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8728         }
8729         ndr->depth--;
8730         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8731         ndr->depth++;
8732         if (r->default_datatype) {
8733                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8734         }
8735         ndr->depth--;
8736         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);
8737         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8738         ndr->depth++;
8739         if (r->dependent_files) {
8740                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8741         }
8742         ndr->depth--;
8743         ndr->depth--;
8744 }
8745
8746 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8747 {
8748         if (ndr_flags & NDR_SCALARS) {
8749                 NDR_CHECK(ndr_push_align(ndr, 5));
8750                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8756                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8758                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8760                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8763                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8764         }
8765         if (ndr_flags & NDR_BUFFERS) {
8766                 if (r->driver_name) {
8767                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8768                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8770                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8771                 }
8772                 if (r->architecture) {
8773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8776                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8777                 }
8778                 if (r->driver_path) {
8779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8783                 }
8784                 if (r->data_file) {
8785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8787                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8788                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8789                 }
8790                 if (r->config_file) {
8791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8793                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8794                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8795                 }
8796                 if (r->help_file) {
8797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8799                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8800                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8801                 }
8802                 if (r->monitor_name) {
8803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8806                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8807                 }
8808                 if (r->default_datatype) {
8809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8812                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8813                 }
8814                 if (r->dependent_files) {
8815                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8816                 }
8817                 if (r->previous_names) {
8818                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8819                 }
8820         }
8821         return NDR_ERR_SUCCESS;
8822 }
8823
8824 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8825 {
8826         uint32_t _ptr_driver_name;
8827         TALLOC_CTX *_mem_save_driver_name_0;
8828         uint32_t _ptr_architecture;
8829         TALLOC_CTX *_mem_save_architecture_0;
8830         uint32_t _ptr_driver_path;
8831         TALLOC_CTX *_mem_save_driver_path_0;
8832         uint32_t _ptr_data_file;
8833         TALLOC_CTX *_mem_save_data_file_0;
8834         uint32_t _ptr_config_file;
8835         TALLOC_CTX *_mem_save_config_file_0;
8836         uint32_t _ptr_help_file;
8837         TALLOC_CTX *_mem_save_help_file_0;
8838         uint32_t _ptr_monitor_name;
8839         TALLOC_CTX *_mem_save_monitor_name_0;
8840         uint32_t _ptr_default_datatype;
8841         TALLOC_CTX *_mem_save_default_datatype_0;
8842         uint32_t _ptr_dependent_files;
8843         TALLOC_CTX *_mem_save_dependent_files_0;
8844         uint32_t _ptr_previous_names;
8845         TALLOC_CTX *_mem_save_previous_names_0;
8846         if (ndr_flags & NDR_SCALARS) {
8847                 NDR_CHECK(ndr_pull_align(ndr, 5));
8848                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8849                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8850                 if (_ptr_driver_name) {
8851                         NDR_PULL_ALLOC(ndr, r->driver_name);
8852                 } else {
8853                         r->driver_name = NULL;
8854                 }
8855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8856                 if (_ptr_architecture) {
8857                         NDR_PULL_ALLOC(ndr, r->architecture);
8858                 } else {
8859                         r->architecture = NULL;
8860                 }
8861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8862                 if (_ptr_driver_path) {
8863                         NDR_PULL_ALLOC(ndr, r->driver_path);
8864                 } else {
8865                         r->driver_path = NULL;
8866                 }
8867                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8868                 if (_ptr_data_file) {
8869                         NDR_PULL_ALLOC(ndr, r->data_file);
8870                 } else {
8871                         r->data_file = NULL;
8872                 }
8873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8874                 if (_ptr_config_file) {
8875                         NDR_PULL_ALLOC(ndr, r->config_file);
8876                 } else {
8877                         r->config_file = NULL;
8878                 }
8879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8880                 if (_ptr_help_file) {
8881                         NDR_PULL_ALLOC(ndr, r->help_file);
8882                 } else {
8883                         r->help_file = NULL;
8884                 }
8885                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8886                 if (_ptr_monitor_name) {
8887                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8888                 } else {
8889                         r->monitor_name = NULL;
8890                 }
8891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8892                 if (_ptr_default_datatype) {
8893                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8894                 } else {
8895                         r->default_datatype = NULL;
8896                 }
8897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8899                 if (_ptr_dependent_files) {
8900                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8901                 } else {
8902                         r->dependent_files = NULL;
8903                 }
8904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8906                 if (_ptr_previous_names) {
8907                         NDR_PULL_ALLOC(ndr, r->previous_names);
8908                 } else {
8909                         r->previous_names = NULL;
8910                 }
8911                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8912         }
8913         if (ndr_flags & NDR_BUFFERS) {
8914                 if (r->driver_name) {
8915                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8916                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8919                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8920                                 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));
8921                         }
8922                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8923                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8925                 }
8926                 if (r->architecture) {
8927                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8928                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8929                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8930                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8931                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8932                                 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));
8933                         }
8934                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8937                 }
8938                 if (r->driver_path) {
8939                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8940                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8941                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8942                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8943                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8944                                 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));
8945                         }
8946                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8947                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8949                 }
8950                 if (r->data_file) {
8951                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8952                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8955                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8956                                 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));
8957                         }
8958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8959                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8961                 }
8962                 if (r->config_file) {
8963                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8964                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8965                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8966                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8967                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8968                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8969                         }
8970                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8971                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8972                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8973                 }
8974                 if (r->help_file) {
8975                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8976                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8978                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8979                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8980                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8981                         }
8982                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8983                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8985                 }
8986                 if (r->monitor_name) {
8987                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8988                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8989                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8990                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8991                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8992                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8993                         }
8994                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8995                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8997                 }
8998                 if (r->default_datatype) {
8999                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9000                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9001                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9002                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9003                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9004                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9005                         }
9006                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9007                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9009                 }
9010                 if (r->dependent_files) {
9011                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9012                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9013                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9015                 }
9016                 if (r->previous_names) {
9017                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9018                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9019                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9021                 }
9022         }
9023         return NDR_ERR_SUCCESS;
9024 }
9025
9026 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9027 {
9028         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9029         ndr->depth++;
9030         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9031         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9032         ndr->depth++;
9033         if (r->driver_name) {
9034                 ndr_print_string(ndr, "driver_name", r->driver_name);
9035         }
9036         ndr->depth--;
9037         ndr_print_ptr(ndr, "architecture", r->architecture);
9038         ndr->depth++;
9039         if (r->architecture) {
9040                 ndr_print_string(ndr, "architecture", r->architecture);
9041         }
9042         ndr->depth--;
9043         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9044         ndr->depth++;
9045         if (r->driver_path) {
9046                 ndr_print_string(ndr, "driver_path", r->driver_path);
9047         }
9048         ndr->depth--;
9049         ndr_print_ptr(ndr, "data_file", r->data_file);
9050         ndr->depth++;
9051         if (r->data_file) {
9052                 ndr_print_string(ndr, "data_file", r->data_file);
9053         }
9054         ndr->depth--;
9055         ndr_print_ptr(ndr, "config_file", r->config_file);
9056         ndr->depth++;
9057         if (r->config_file) {
9058                 ndr_print_string(ndr, "config_file", r->config_file);
9059         }
9060         ndr->depth--;
9061         ndr_print_ptr(ndr, "help_file", r->help_file);
9062         ndr->depth++;
9063         if (r->help_file) {
9064                 ndr_print_string(ndr, "help_file", r->help_file);
9065         }
9066         ndr->depth--;
9067         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9068         ndr->depth++;
9069         if (r->monitor_name) {
9070                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9071         }
9072         ndr->depth--;
9073         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9074         ndr->depth++;
9075         if (r->default_datatype) {
9076                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9077         }
9078         ndr->depth--;
9079         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);
9080         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9081         ndr->depth++;
9082         if (r->dependent_files) {
9083                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9084         }
9085         ndr->depth--;
9086         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);
9087         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9088         ndr->depth++;
9089         if (r->previous_names) {
9090                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9091         }
9092         ndr->depth--;
9093         ndr->depth--;
9094 }
9095
9096 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9097 {
9098         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9099         return NDR_ERR_SUCCESS;
9100 }
9101
9102 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9103 {
9104         uint32_t v;
9105         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9106         *r = v;
9107         return NDR_ERR_SUCCESS;
9108 }
9109
9110 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9111 {
9112         ndr_print_uint32(ndr, name, r);
9113         ndr->depth++;
9114         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9115         ndr->depth--;
9116 }
9117
9118 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9119 {
9120         if (ndr_flags & NDR_SCALARS) {
9121                 NDR_CHECK(ndr_push_align(ndr, 8));
9122                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9124                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9126                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9135                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9136                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9139                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9140                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9141                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9142         }
9143         if (ndr_flags & NDR_BUFFERS) {
9144                 if (r->driver_name) {
9145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9147                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9148                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9149                 }
9150                 if (r->architecture) {
9151                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9152                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9153                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9154                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9155                 }
9156                 if (r->driver_path) {
9157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9158                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9159                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9160                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9161                 }
9162                 if (r->data_file) {
9163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9164                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9165                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9166                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9167                 }
9168                 if (r->config_file) {
9169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9173                 }
9174                 if (r->help_file) {
9175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9178                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9179                 }
9180                 if (r->monitor_name) {
9181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9184                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9185                 }
9186                 if (r->default_datatype) {
9187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9190                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9191                 }
9192                 if (r->dependent_files) {
9193                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9194                 }
9195                 if (r->previous_names) {
9196                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9197                 }
9198                 if (r->manufacturer_name) {
9199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9203                 }
9204                 if (r->manufacturer_url) {
9205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9208                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9209                 }
9210                 if (r->hardware_id) {
9211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9214                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9215                 }
9216                 if (r->provider) {
9217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9221                 }
9222         }
9223         return NDR_ERR_SUCCESS;
9224 }
9225
9226 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9227 {
9228         uint32_t _ptr_driver_name;
9229         TALLOC_CTX *_mem_save_driver_name_0;
9230         uint32_t _ptr_architecture;
9231         TALLOC_CTX *_mem_save_architecture_0;
9232         uint32_t _ptr_driver_path;
9233         TALLOC_CTX *_mem_save_driver_path_0;
9234         uint32_t _ptr_data_file;
9235         TALLOC_CTX *_mem_save_data_file_0;
9236         uint32_t _ptr_config_file;
9237         TALLOC_CTX *_mem_save_config_file_0;
9238         uint32_t _ptr_help_file;
9239         TALLOC_CTX *_mem_save_help_file_0;
9240         uint32_t _ptr_monitor_name;
9241         TALLOC_CTX *_mem_save_monitor_name_0;
9242         uint32_t _ptr_default_datatype;
9243         TALLOC_CTX *_mem_save_default_datatype_0;
9244         uint32_t _ptr_dependent_files;
9245         TALLOC_CTX *_mem_save_dependent_files_0;
9246         uint32_t _ptr_previous_names;
9247         TALLOC_CTX *_mem_save_previous_names_0;
9248         uint32_t _ptr_manufacturer_name;
9249         TALLOC_CTX *_mem_save_manufacturer_name_0;
9250         uint32_t _ptr_manufacturer_url;
9251         TALLOC_CTX *_mem_save_manufacturer_url_0;
9252         uint32_t _ptr_hardware_id;
9253         TALLOC_CTX *_mem_save_hardware_id_0;
9254         uint32_t _ptr_provider;
9255         TALLOC_CTX *_mem_save_provider_0;
9256         if (ndr_flags & NDR_SCALARS) {
9257                 NDR_CHECK(ndr_pull_align(ndr, 8));
9258                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9260                 if (_ptr_driver_name) {
9261                         NDR_PULL_ALLOC(ndr, r->driver_name);
9262                 } else {
9263                         r->driver_name = NULL;
9264                 }
9265                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9266                 if (_ptr_architecture) {
9267                         NDR_PULL_ALLOC(ndr, r->architecture);
9268                 } else {
9269                         r->architecture = NULL;
9270                 }
9271                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9272                 if (_ptr_driver_path) {
9273                         NDR_PULL_ALLOC(ndr, r->driver_path);
9274                 } else {
9275                         r->driver_path = NULL;
9276                 }
9277                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9278                 if (_ptr_data_file) {
9279                         NDR_PULL_ALLOC(ndr, r->data_file);
9280                 } else {
9281                         r->data_file = NULL;
9282                 }
9283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9284                 if (_ptr_config_file) {
9285                         NDR_PULL_ALLOC(ndr, r->config_file);
9286                 } else {
9287                         r->config_file = NULL;
9288                 }
9289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9290                 if (_ptr_help_file) {
9291                         NDR_PULL_ALLOC(ndr, r->help_file);
9292                 } else {
9293                         r->help_file = NULL;
9294                 }
9295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9296                 if (_ptr_monitor_name) {
9297                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9298                 } else {
9299                         r->monitor_name = NULL;
9300                 }
9301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9302                 if (_ptr_default_datatype) {
9303                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9304                 } else {
9305                         r->default_datatype = NULL;
9306                 }
9307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9309                 if (_ptr_dependent_files) {
9310                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9311                 } else {
9312                         r->dependent_files = NULL;
9313                 }
9314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9316                 if (_ptr_previous_names) {
9317                         NDR_PULL_ALLOC(ndr, r->previous_names);
9318                 } else {
9319                         r->previous_names = NULL;
9320                 }
9321                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9322                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9324                 if (_ptr_manufacturer_name) {
9325                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9326                 } else {
9327                         r->manufacturer_name = NULL;
9328                 }
9329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9330                 if (_ptr_manufacturer_url) {
9331                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9332                 } else {
9333                         r->manufacturer_url = NULL;
9334                 }
9335                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9336                 if (_ptr_hardware_id) {
9337                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9338                 } else {
9339                         r->hardware_id = NULL;
9340                 }
9341                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9342                 if (_ptr_provider) {
9343                         NDR_PULL_ALLOC(ndr, r->provider);
9344                 } else {
9345                         r->provider = NULL;
9346                 }
9347                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9348         }
9349         if (ndr_flags & NDR_BUFFERS) {
9350                 if (r->driver_name) {
9351                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9352                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9353                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9354                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9355                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9356                                 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));
9357                         }
9358                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9359                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9361                 }
9362                 if (r->architecture) {
9363                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9364                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9367                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9368                                 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));
9369                         }
9370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9373                 }
9374                 if (r->driver_path) {
9375                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9376                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9379                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9380                                 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));
9381                         }
9382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9385                 }
9386                 if (r->data_file) {
9387                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9388                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9391                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9392                                 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));
9393                         }
9394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9397                 }
9398                 if (r->config_file) {
9399                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9400                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9402                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9403                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9404                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9405                         }
9406                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9407                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9409                 }
9410                 if (r->help_file) {
9411                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9412                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9413                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9414                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9415                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9416                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9417                         }
9418                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9419                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9421                 }
9422                 if (r->monitor_name) {
9423                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9424                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9427                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9428                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9429                         }
9430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9433                 }
9434                 if (r->default_datatype) {
9435                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9436                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9438                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9439                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9440                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9441                         }
9442                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9445                 }
9446                 if (r->dependent_files) {
9447                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9448                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9449                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9451                 }
9452                 if (r->previous_names) {
9453                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9454                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9455                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9457                 }
9458                 if (r->manufacturer_name) {
9459                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9460                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9463                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9464                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9465                         }
9466                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9467                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9469                 }
9470                 if (r->manufacturer_url) {
9471                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9472                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9475                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9476                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9477                         }
9478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9479                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9481                 }
9482                 if (r->hardware_id) {
9483                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9484                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9486                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9487                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9488                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9489                         }
9490                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9491                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9493                 }
9494                 if (r->provider) {
9495                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9496                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9499                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9500                                 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));
9501                         }
9502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9505                 }
9506         }
9507         return NDR_ERR_SUCCESS;
9508 }
9509
9510 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9511 {
9512         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9513         ndr->depth++;
9514         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9515         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9516         ndr->depth++;
9517         if (r->driver_name) {
9518                 ndr_print_string(ndr, "driver_name", r->driver_name);
9519         }
9520         ndr->depth--;
9521         ndr_print_ptr(ndr, "architecture", r->architecture);
9522         ndr->depth++;
9523         if (r->architecture) {
9524                 ndr_print_string(ndr, "architecture", r->architecture);
9525         }
9526         ndr->depth--;
9527         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9528         ndr->depth++;
9529         if (r->driver_path) {
9530                 ndr_print_string(ndr, "driver_path", r->driver_path);
9531         }
9532         ndr->depth--;
9533         ndr_print_ptr(ndr, "data_file", r->data_file);
9534         ndr->depth++;
9535         if (r->data_file) {
9536                 ndr_print_string(ndr, "data_file", r->data_file);
9537         }
9538         ndr->depth--;
9539         ndr_print_ptr(ndr, "config_file", r->config_file);
9540         ndr->depth++;
9541         if (r->config_file) {
9542                 ndr_print_string(ndr, "config_file", r->config_file);
9543         }
9544         ndr->depth--;
9545         ndr_print_ptr(ndr, "help_file", r->help_file);
9546         ndr->depth++;
9547         if (r->help_file) {
9548                 ndr_print_string(ndr, "help_file", r->help_file);
9549         }
9550         ndr->depth--;
9551         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9552         ndr->depth++;
9553         if (r->monitor_name) {
9554                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9555         }
9556         ndr->depth--;
9557         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9558         ndr->depth++;
9559         if (r->default_datatype) {
9560                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9561         }
9562         ndr->depth--;
9563         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);
9564         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9565         ndr->depth++;
9566         if (r->dependent_files) {
9567                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9568         }
9569         ndr->depth--;
9570         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);
9571         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9572         ndr->depth++;
9573         if (r->previous_names) {
9574                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9575         }
9576         ndr->depth--;
9577         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9578         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9579         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9580         ndr->depth++;
9581         if (r->manufacturer_name) {
9582                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9583         }
9584         ndr->depth--;
9585         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9586         ndr->depth++;
9587         if (r->manufacturer_url) {
9588                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9589         }
9590         ndr->depth--;
9591         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9592         ndr->depth++;
9593         if (r->hardware_id) {
9594                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9595         }
9596         ndr->depth--;
9597         ndr_print_ptr(ndr, "provider", r->provider);
9598         ndr->depth++;
9599         if (r->provider) {
9600                 ndr_print_string(ndr, "provider", r->provider);
9601         }
9602         ndr->depth--;
9603         ndr->depth--;
9604 }
9605
9606 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9607 {
9608         if (ndr_flags & NDR_SCALARS) {
9609                 NDR_CHECK(ndr_push_align(ndr, 8));
9610                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9612                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9623                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9624                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9625                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9628                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9636                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9637                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9638                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9639                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9640         }
9641         if (ndr_flags & NDR_BUFFERS) {
9642                 if (r->driver_name) {
9643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9644                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9646                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9647                 }
9648                 if (r->architecture) {
9649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9652                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9653                 }
9654                 if (r->driver_path) {
9655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9659                 }
9660                 if (r->data_file) {
9661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9665                 }
9666                 if (r->config_file) {
9667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9669                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9670                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9671                 }
9672                 if (r->help_file) {
9673                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9674                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9675                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9677                 }
9678                 if (r->monitor_name) {
9679                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9681                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9682                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9683                 }
9684                 if (r->default_datatype) {
9685                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9689                 }
9690                 if (r->dependent_files) {
9691                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9692                 }
9693                 if (r->previous_names) {
9694                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9695                 }
9696                 if (r->manufacturer_name) {
9697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9700                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9701                 }
9702                 if (r->manufacturer_url) {
9703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9706                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9707                 }
9708                 if (r->hardware_id) {
9709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9713                 }
9714                 if (r->provider) {
9715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9718                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9719                 }
9720                 if (r->print_processor) {
9721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9725                 }
9726                 if (r->vendor_setup) {
9727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, 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->vendor_setup, CH_UTF16)));
9730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9731                 }
9732                 if (r->color_profiles) {
9733                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9734                 }
9735                 if (r->inf_path) {
9736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9737                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9740                 }
9741                 if (r->core_driver_dependencies) {
9742                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9743                 }
9744         }
9745         return NDR_ERR_SUCCESS;
9746 }
9747
9748 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9749 {
9750         uint32_t _ptr_driver_name;
9751         TALLOC_CTX *_mem_save_driver_name_0;
9752         uint32_t _ptr_architecture;
9753         TALLOC_CTX *_mem_save_architecture_0;
9754         uint32_t _ptr_driver_path;
9755         TALLOC_CTX *_mem_save_driver_path_0;
9756         uint32_t _ptr_data_file;
9757         TALLOC_CTX *_mem_save_data_file_0;
9758         uint32_t _ptr_config_file;
9759         TALLOC_CTX *_mem_save_config_file_0;
9760         uint32_t _ptr_help_file;
9761         TALLOC_CTX *_mem_save_help_file_0;
9762         uint32_t _ptr_monitor_name;
9763         TALLOC_CTX *_mem_save_monitor_name_0;
9764         uint32_t _ptr_default_datatype;
9765         TALLOC_CTX *_mem_save_default_datatype_0;
9766         uint32_t _ptr_dependent_files;
9767         TALLOC_CTX *_mem_save_dependent_files_0;
9768         uint32_t _ptr_previous_names;
9769         TALLOC_CTX *_mem_save_previous_names_0;
9770         uint32_t _ptr_manufacturer_name;
9771         TALLOC_CTX *_mem_save_manufacturer_name_0;
9772         uint32_t _ptr_manufacturer_url;
9773         TALLOC_CTX *_mem_save_manufacturer_url_0;
9774         uint32_t _ptr_hardware_id;
9775         TALLOC_CTX *_mem_save_hardware_id_0;
9776         uint32_t _ptr_provider;
9777         TALLOC_CTX *_mem_save_provider_0;
9778         uint32_t _ptr_print_processor;
9779         TALLOC_CTX *_mem_save_print_processor_0;
9780         uint32_t _ptr_vendor_setup;
9781         TALLOC_CTX *_mem_save_vendor_setup_0;
9782         uint32_t _ptr_color_profiles;
9783         TALLOC_CTX *_mem_save_color_profiles_0;
9784         uint32_t _ptr_inf_path;
9785         TALLOC_CTX *_mem_save_inf_path_0;
9786         uint32_t _ptr_core_driver_dependencies;
9787         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9788         if (ndr_flags & NDR_SCALARS) {
9789                 NDR_CHECK(ndr_pull_align(ndr, 8));
9790                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9792                 if (_ptr_driver_name) {
9793                         NDR_PULL_ALLOC(ndr, r->driver_name);
9794                 } else {
9795                         r->driver_name = NULL;
9796                 }
9797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9798                 if (_ptr_architecture) {
9799                         NDR_PULL_ALLOC(ndr, r->architecture);
9800                 } else {
9801                         r->architecture = NULL;
9802                 }
9803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9804                 if (_ptr_driver_path) {
9805                         NDR_PULL_ALLOC(ndr, r->driver_path);
9806                 } else {
9807                         r->driver_path = NULL;
9808                 }
9809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9810                 if (_ptr_data_file) {
9811                         NDR_PULL_ALLOC(ndr, r->data_file);
9812                 } else {
9813                         r->data_file = NULL;
9814                 }
9815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9816                 if (_ptr_config_file) {
9817                         NDR_PULL_ALLOC(ndr, r->config_file);
9818                 } else {
9819                         r->config_file = NULL;
9820                 }
9821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9822                 if (_ptr_help_file) {
9823                         NDR_PULL_ALLOC(ndr, r->help_file);
9824                 } else {
9825                         r->help_file = NULL;
9826                 }
9827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9828                 if (_ptr_monitor_name) {
9829                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9830                 } else {
9831                         r->monitor_name = NULL;
9832                 }
9833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9834                 if (_ptr_default_datatype) {
9835                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9836                 } else {
9837                         r->default_datatype = NULL;
9838                 }
9839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9841                 if (_ptr_dependent_files) {
9842                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9843                 } else {
9844                         r->dependent_files = NULL;
9845                 }
9846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9848                 if (_ptr_previous_names) {
9849                         NDR_PULL_ALLOC(ndr, r->previous_names);
9850                 } else {
9851                         r->previous_names = NULL;
9852                 }
9853                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9854                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9856                 if (_ptr_manufacturer_name) {
9857                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9858                 } else {
9859                         r->manufacturer_name = NULL;
9860                 }
9861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9862                 if (_ptr_manufacturer_url) {
9863                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9864                 } else {
9865                         r->manufacturer_url = NULL;
9866                 }
9867                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9868                 if (_ptr_hardware_id) {
9869                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9870                 } else {
9871                         r->hardware_id = NULL;
9872                 }
9873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9874                 if (_ptr_provider) {
9875                         NDR_PULL_ALLOC(ndr, r->provider);
9876                 } else {
9877                         r->provider = NULL;
9878                 }
9879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9880                 if (_ptr_print_processor) {
9881                         NDR_PULL_ALLOC(ndr, r->print_processor);
9882                 } else {
9883                         r->print_processor = NULL;
9884                 }
9885                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9886                 if (_ptr_vendor_setup) {
9887                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9888                 } else {
9889                         r->vendor_setup = NULL;
9890                 }
9891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9893                 if (_ptr_color_profiles) {
9894                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9895                 } else {
9896                         r->color_profiles = NULL;
9897                 }
9898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9899                 if (_ptr_inf_path) {
9900                         NDR_PULL_ALLOC(ndr, r->inf_path);
9901                 } else {
9902                         r->inf_path = NULL;
9903                 }
9904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9907                 if (_ptr_core_driver_dependencies) {
9908                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9909                 } else {
9910                         r->core_driver_dependencies = NULL;
9911                 }
9912                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9913                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9914                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9915         }
9916         if (ndr_flags & NDR_BUFFERS) {
9917                 if (r->driver_name) {
9918                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9919                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9922                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9923                                 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));
9924                         }
9925                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9928                 }
9929                 if (r->architecture) {
9930                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9931                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9934                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9935                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9936                         }
9937                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9938                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9940                 }
9941                 if (r->driver_path) {
9942                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9943                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9944                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9945                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9946                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9947                                 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));
9948                         }
9949                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9950                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9951                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9952                 }
9953                 if (r->data_file) {
9954                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9955                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9956                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9957                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9958                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9959                                 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));
9960                         }
9961                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9962                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9964                 }
9965                 if (r->config_file) {
9966                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9967                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9970                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9972                         }
9973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9976                 }
9977                 if (r->help_file) {
9978                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9979                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9982                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9984                         }
9985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9988                 }
9989                 if (r->monitor_name) {
9990                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9991                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9994                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9995                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9996                         }
9997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10000                 }
10001                 if (r->default_datatype) {
10002                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10003                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10004                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
10005                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
10006                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
10007                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
10008                         }
10009                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10010                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10012                 }
10013                 if (r->dependent_files) {
10014                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10015                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10016                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10017                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10018                 }
10019                 if (r->previous_names) {
10020                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10021                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10022                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10024                 }
10025                 if (r->manufacturer_name) {
10026                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10027                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10028                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10029                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10030                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10031                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
10032                         }
10033                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10034                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10036                 }
10037                 if (r->manufacturer_url) {
10038                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10039                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10040                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10041                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10042                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10043                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
10044                         }
10045                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10046                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10047                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10048                 }
10049                 if (r->hardware_id) {
10050                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10051                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10052                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10053                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10054                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10055                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
10056                         }
10057                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10058                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10060                 }
10061                 if (r->provider) {
10062                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10063                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10064                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10065                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10066                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10067                                 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));
10068                         }
10069                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10070                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10072                 }
10073                 if (r->print_processor) {
10074                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10075                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10076                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10077                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10078                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10079                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
10080                         }
10081                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10082                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10084                 }
10085                 if (r->vendor_setup) {
10086                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10087                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10090                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10091                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
10092                         }
10093                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10094                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10096                 }
10097                 if (r->color_profiles) {
10098                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10099                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10100                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10102                 }
10103                 if (r->inf_path) {
10104                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10105                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10108                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10109                                 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));
10110                         }
10111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10114                 }
10115                 if (r->core_driver_dependencies) {
10116                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10117                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10118                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10120                 }
10121         }
10122         return NDR_ERR_SUCCESS;
10123 }
10124
10125 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10126 {
10127         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10128         ndr->depth++;
10129         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10130         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10131         ndr->depth++;
10132         if (r->driver_name) {
10133                 ndr_print_string(ndr, "driver_name", r->driver_name);
10134         }
10135         ndr->depth--;
10136         ndr_print_ptr(ndr, "architecture", r->architecture);
10137         ndr->depth++;
10138         if (r->architecture) {
10139                 ndr_print_string(ndr, "architecture", r->architecture);
10140         }
10141         ndr->depth--;
10142         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10143         ndr->depth++;
10144         if (r->driver_path) {
10145                 ndr_print_string(ndr, "driver_path", r->driver_path);
10146         }
10147         ndr->depth--;
10148         ndr_print_ptr(ndr, "data_file", r->data_file);
10149         ndr->depth++;
10150         if (r->data_file) {
10151                 ndr_print_string(ndr, "data_file", r->data_file);
10152         }
10153         ndr->depth--;
10154         ndr_print_ptr(ndr, "config_file", r->config_file);
10155         ndr->depth++;
10156         if (r->config_file) {
10157                 ndr_print_string(ndr, "config_file", r->config_file);
10158         }
10159         ndr->depth--;
10160         ndr_print_ptr(ndr, "help_file", r->help_file);
10161         ndr->depth++;
10162         if (r->help_file) {
10163                 ndr_print_string(ndr, "help_file", r->help_file);
10164         }
10165         ndr->depth--;
10166         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10167         ndr->depth++;
10168         if (r->monitor_name) {
10169                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10170         }
10171         ndr->depth--;
10172         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10173         ndr->depth++;
10174         if (r->default_datatype) {
10175                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10176         }
10177         ndr->depth--;
10178         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);
10179         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10180         ndr->depth++;
10181         if (r->dependent_files) {
10182                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10183         }
10184         ndr->depth--;
10185         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);
10186         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10187         ndr->depth++;
10188         if (r->previous_names) {
10189                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10190         }
10191         ndr->depth--;
10192         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10193         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10194         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10195         ndr->depth++;
10196         if (r->manufacturer_name) {
10197                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10198         }
10199         ndr->depth--;
10200         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10201         ndr->depth++;
10202         if (r->manufacturer_url) {
10203                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10204         }
10205         ndr->depth--;
10206         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10207         ndr->depth++;
10208         if (r->hardware_id) {
10209                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10210         }
10211         ndr->depth--;
10212         ndr_print_ptr(ndr, "provider", r->provider);
10213         ndr->depth++;
10214         if (r->provider) {
10215                 ndr_print_string(ndr, "provider", r->provider);
10216         }
10217         ndr->depth--;
10218         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10219         ndr->depth++;
10220         if (r->print_processor) {
10221                 ndr_print_string(ndr, "print_processor", r->print_processor);
10222         }
10223         ndr->depth--;
10224         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10225         ndr->depth++;
10226         if (r->vendor_setup) {
10227                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10228         }
10229         ndr->depth--;
10230         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);
10231         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10232         ndr->depth++;
10233         if (r->color_profiles) {
10234                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10235         }
10236         ndr->depth--;
10237         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10238         ndr->depth++;
10239         if (r->inf_path) {
10240                 ndr_print_string(ndr, "inf_path", r->inf_path);
10241         }
10242         ndr->depth--;
10243         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10244         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);
10245         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10246         ndr->depth++;
10247         if (r->core_driver_dependencies) {
10248                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10249         }
10250         ndr->depth--;
10251         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10252         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10253         ndr->depth--;
10254 }
10255
10256 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10257 {
10258         if (ndr_flags & NDR_SCALARS) {
10259                 int level = ndr_push_get_switch_value(ndr, r);
10260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10261                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10262                 switch (level) {
10263                         case 1: {
10264                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10265                         break; }
10266
10267                         case 2: {
10268                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10269                         break; }
10270
10271                         case 3: {
10272                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10273                         break; }
10274
10275                         case 4: {
10276                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10277                         break; }
10278
10279                         case 6: {
10280                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10281                         break; }
10282
10283                         case 8: {
10284                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10285                         break; }
10286
10287                         default:
10288                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10289                 }
10290         }
10291         if (ndr_flags & NDR_BUFFERS) {
10292                 int level = ndr_push_get_switch_value(ndr, r);
10293                 switch (level) {
10294                         case 1:
10295                                 if (r->info1) {
10296                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10297                                 }
10298                         break;
10299
10300                         case 2:
10301                                 if (r->info2) {
10302                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10303                                 }
10304                         break;
10305
10306                         case 3:
10307                                 if (r->info3) {
10308                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10309                                 }
10310                         break;
10311
10312                         case 4:
10313                                 if (r->info4) {
10314                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10315                                 }
10316                         break;
10317
10318                         case 6:
10319                                 if (r->info6) {
10320                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10321                                 }
10322                         break;
10323
10324                         case 8:
10325                                 if (r->info8) {
10326                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10327                                 }
10328                         break;
10329
10330                         default:
10331                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10332                 }
10333         }
10334         return NDR_ERR_SUCCESS;
10335 }
10336
10337 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10338 {
10339         int level;
10340         uint32_t _level;
10341         TALLOC_CTX *_mem_save_info1_0;
10342         TALLOC_CTX *_mem_save_info2_0;
10343         TALLOC_CTX *_mem_save_info3_0;
10344         TALLOC_CTX *_mem_save_info4_0;
10345         TALLOC_CTX *_mem_save_info6_0;
10346         TALLOC_CTX *_mem_save_info8_0;
10347         level = ndr_pull_get_switch_value(ndr, r);
10348         if (ndr_flags & NDR_SCALARS) {
10349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10350                 if (_level != level) {
10351                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10352                 }
10353                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10354                 switch (level) {
10355                         case 1: {
10356                                 uint32_t _ptr_info1;
10357                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10358                                 if (_ptr_info1) {
10359                                         NDR_PULL_ALLOC(ndr, r->info1);
10360                                 } else {
10361                                         r->info1 = NULL;
10362                                 }
10363                         break; }
10364
10365                         case 2: {
10366                                 uint32_t _ptr_info2;
10367                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10368                                 if (_ptr_info2) {
10369                                         NDR_PULL_ALLOC(ndr, r->info2);
10370                                 } else {
10371                                         r->info2 = NULL;
10372                                 }
10373                         break; }
10374
10375                         case 3: {
10376                                 uint32_t _ptr_info3;
10377                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10378                                 if (_ptr_info3) {
10379                                         NDR_PULL_ALLOC(ndr, r->info3);
10380                                 } else {
10381                                         r->info3 = NULL;
10382                                 }
10383                         break; }
10384
10385                         case 4: {
10386                                 uint32_t _ptr_info4;
10387                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10388                                 if (_ptr_info4) {
10389                                         NDR_PULL_ALLOC(ndr, r->info4);
10390                                 } else {
10391                                         r->info4 = NULL;
10392                                 }
10393                         break; }
10394
10395                         case 6: {
10396                                 uint32_t _ptr_info6;
10397                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10398                                 if (_ptr_info6) {
10399                                         NDR_PULL_ALLOC(ndr, r->info6);
10400                                 } else {
10401                                         r->info6 = NULL;
10402                                 }
10403                         break; }
10404
10405                         case 8: {
10406                                 uint32_t _ptr_info8;
10407                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10408                                 if (_ptr_info8) {
10409                                         NDR_PULL_ALLOC(ndr, r->info8);
10410                                 } else {
10411                                         r->info8 = NULL;
10412                                 }
10413                         break; }
10414
10415                         default:
10416                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10417                 }
10418         }
10419         if (ndr_flags & NDR_BUFFERS) {
10420                 switch (level) {
10421                         case 1:
10422                                 if (r->info1) {
10423                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10424                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10425                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10426                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10427                                 }
10428                         break;
10429
10430                         case 2:
10431                                 if (r->info2) {
10432                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10433                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10434                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10435                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10436                                 }
10437                         break;
10438
10439                         case 3:
10440                                 if (r->info3) {
10441                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10442                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10443                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10444                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10445                                 }
10446                         break;
10447
10448                         case 4:
10449                                 if (r->info4) {
10450                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10451                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10452                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10453                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10454                                 }
10455                         break;
10456
10457                         case 6:
10458                                 if (r->info6) {
10459                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10460                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10461                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10462                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10463                                 }
10464                         break;
10465
10466                         case 8:
10467                                 if (r->info8) {
10468                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10469                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10470                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10471                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10472                                 }
10473                         break;
10474
10475                         default:
10476                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10477                 }
10478         }
10479         return NDR_ERR_SUCCESS;
10480 }
10481
10482 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10483 {
10484         int level;
10485         level = ndr_print_get_switch_value(ndr, r);
10486         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10487         switch (level) {
10488                 case 1:
10489                         ndr_print_ptr(ndr, "info1", r->info1);
10490                         ndr->depth++;
10491                         if (r->info1) {
10492                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10493                         }
10494                         ndr->depth--;
10495                 break;
10496
10497                 case 2:
10498                         ndr_print_ptr(ndr, "info2", r->info2);
10499                         ndr->depth++;
10500                         if (r->info2) {
10501                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10502                         }
10503                         ndr->depth--;
10504                 break;
10505
10506                 case 3:
10507                         ndr_print_ptr(ndr, "info3", r->info3);
10508                         ndr->depth++;
10509                         if (r->info3) {
10510                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10511                         }
10512                         ndr->depth--;
10513                 break;
10514
10515                 case 4:
10516                         ndr_print_ptr(ndr, "info4", r->info4);
10517                         ndr->depth++;
10518                         if (r->info4) {
10519                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10520                         }
10521                         ndr->depth--;
10522                 break;
10523
10524                 case 6:
10525                         ndr_print_ptr(ndr, "info6", r->info6);
10526                         ndr->depth++;
10527                         if (r->info6) {
10528                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10529                         }
10530                         ndr->depth--;
10531                 break;
10532
10533                 case 8:
10534                         ndr_print_ptr(ndr, "info8", r->info8);
10535                         ndr->depth++;
10536                         if (r->info8) {
10537                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10538                         }
10539                         ndr->depth--;
10540                 break;
10541
10542                 default:
10543                         ndr_print_bad_level(ndr, name, level);
10544         }
10545 }
10546
10547 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10548 {
10549         if (ndr_flags & NDR_SCALARS) {
10550                 NDR_CHECK(ndr_push_align(ndr, 5));
10551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10552                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10553                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10554                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10555         }
10556         if (ndr_flags & NDR_BUFFERS) {
10557                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10558         }
10559         return NDR_ERR_SUCCESS;
10560 }
10561
10562 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10563 {
10564         if (ndr_flags & NDR_SCALARS) {
10565                 NDR_CHECK(ndr_pull_align(ndr, 5));
10566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10567                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10568                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10569                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10570         }
10571         if (ndr_flags & NDR_BUFFERS) {
10572                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10573         }
10574         return NDR_ERR_SUCCESS;
10575 }
10576
10577 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10578 {
10579         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10580         ndr->depth++;
10581         ndr_print_uint32(ndr, "level", r->level);
10582         ndr_print_set_switch_value(ndr, &r->info, r->level);
10583         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10584         ndr->depth--;
10585 }
10586
10587 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10588 {
10589         if (ndr_flags & NDR_SCALARS) {
10590                 NDR_CHECK(ndr_push_align(ndr, 5));
10591                 {
10592                         uint32_t _flags_save_string = ndr->flags;
10593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10594                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10595                         ndr->flags = _flags_save_string;
10596                 }
10597                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10598         }
10599         if (ndr_flags & NDR_BUFFERS) {
10600                 {
10601                         uint32_t _flags_save_string = ndr->flags;
10602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10603                         if (r->driver_name) {
10604                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10605                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10606                         }
10607                         ndr->flags = _flags_save_string;
10608                 }
10609         }
10610         return NDR_ERR_SUCCESS;
10611 }
10612
10613 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10614 {
10615         uint32_t _ptr_driver_name;
10616         TALLOC_CTX *_mem_save_driver_name_0;
10617         if (ndr_flags & NDR_SCALARS) {
10618                 NDR_CHECK(ndr_pull_align(ndr, 5));
10619                 {
10620                         uint32_t _flags_save_string = ndr->flags;
10621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10622                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10623                         if (_ptr_driver_name) {
10624                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10625                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10626                         } else {
10627                                 r->driver_name = NULL;
10628                         }
10629                         ndr->flags = _flags_save_string;
10630                 }
10631                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10632         }
10633         if (ndr_flags & NDR_BUFFERS) {
10634                 {
10635                         uint32_t _flags_save_string = ndr->flags;
10636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10637                         if (r->driver_name) {
10638                                 uint32_t _relative_save_offset;
10639                                 _relative_save_offset = ndr->offset;
10640                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10641                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10642                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10643                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10644                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10645                                 if (ndr->offset > ndr->relative_highest_offset) {
10646                                         ndr->relative_highest_offset = ndr->offset;
10647                                 }
10648                                 ndr->offset = _relative_save_offset;
10649                         }
10650                         ndr->flags = _flags_save_string;
10651                 }
10652         }
10653         return NDR_ERR_SUCCESS;
10654 }
10655
10656 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10657 {
10658         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10659         ndr->depth++;
10660         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10661         ndr->depth++;
10662         if (r->driver_name) {
10663                 ndr_print_string(ndr, "driver_name", r->driver_name);
10664         }
10665         ndr->depth--;
10666         ndr->depth--;
10667 }
10668
10669 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10670 {
10671         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10672 }
10673
10674 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10675 {
10676         if (ndr_flags & NDR_SCALARS) {
10677                 NDR_CHECK(ndr_push_align(ndr, 5));
10678                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10679                 {
10680                         uint32_t _flags_save_string = ndr->flags;
10681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10682                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10683                         ndr->flags = _flags_save_string;
10684                 }
10685                 {
10686                         uint32_t _flags_save_string = ndr->flags;
10687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10688                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10689                         ndr->flags = _flags_save_string;
10690                 }
10691                 {
10692                         uint32_t _flags_save_string = ndr->flags;
10693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10694                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10695                         ndr->flags = _flags_save_string;
10696                 }
10697                 {
10698                         uint32_t _flags_save_string = ndr->flags;
10699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10700                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10701                         ndr->flags = _flags_save_string;
10702                 }
10703                 {
10704                         uint32_t _flags_save_string = ndr->flags;
10705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10706                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10707                         ndr->flags = _flags_save_string;
10708                 }
10709                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10710         }
10711         if (ndr_flags & NDR_BUFFERS) {
10712                 {
10713                         uint32_t _flags_save_string = ndr->flags;
10714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10715                         if (r->driver_name) {
10716                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10717                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
10725                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10726                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
10734                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10735                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
10743                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10744                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10745                         }
10746                         ndr->flags = _flags_save_string;
10747                 }
10748                 {
10749                         uint32_t _flags_save_string = ndr->flags;
10750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10751                         if (r->config_file) {
10752                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10753                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10754                         }
10755                         ndr->flags = _flags_save_string;
10756                 }
10757         }
10758         return NDR_ERR_SUCCESS;
10759 }
10760
10761 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10762 {
10763         uint32_t _ptr_driver_name;
10764         TALLOC_CTX *_mem_save_driver_name_0;
10765         uint32_t _ptr_architecture;
10766         TALLOC_CTX *_mem_save_architecture_0;
10767         uint32_t _ptr_driver_path;
10768         TALLOC_CTX *_mem_save_driver_path_0;
10769         uint32_t _ptr_data_file;
10770         TALLOC_CTX *_mem_save_data_file_0;
10771         uint32_t _ptr_config_file;
10772         TALLOC_CTX *_mem_save_config_file_0;
10773         if (ndr_flags & NDR_SCALARS) {
10774                 NDR_CHECK(ndr_pull_align(ndr, 5));
10775                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10776                 {
10777                         uint32_t _flags_save_string = ndr->flags;
10778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10780                         if (_ptr_driver_name) {
10781                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10783                         } else {
10784                                 r->driver_name = NULL;
10785                         }
10786                         ndr->flags = _flags_save_string;
10787                 }
10788                 {
10789                         uint32_t _flags_save_string = ndr->flags;
10790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10792                         if (_ptr_architecture) {
10793                                 NDR_PULL_ALLOC(ndr, r->architecture);
10794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10795                         } else {
10796                                 r->architecture = NULL;
10797                         }
10798                         ndr->flags = _flags_save_string;
10799                 }
10800                 {
10801                         uint32_t _flags_save_string = ndr->flags;
10802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10803                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10804                         if (_ptr_driver_path) {
10805                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10807                         } else {
10808                                 r->driver_path = NULL;
10809                         }
10810                         ndr->flags = _flags_save_string;
10811                 }
10812                 {
10813                         uint32_t _flags_save_string = ndr->flags;
10814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10816                         if (_ptr_data_file) {
10817                                 NDR_PULL_ALLOC(ndr, r->data_file);
10818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10819                         } else {
10820                                 r->data_file = NULL;
10821                         }
10822                         ndr->flags = _flags_save_string;
10823                 }
10824                 {
10825                         uint32_t _flags_save_string = ndr->flags;
10826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10827                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10828                         if (_ptr_config_file) {
10829                                 NDR_PULL_ALLOC(ndr, r->config_file);
10830                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10831                         } else {
10832                                 r->config_file = NULL;
10833                         }
10834                         ndr->flags = _flags_save_string;
10835                 }
10836                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10837         }
10838         if (ndr_flags & NDR_BUFFERS) {
10839                 {
10840                         uint32_t _flags_save_string = ndr->flags;
10841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10842                         if (r->driver_name) {
10843                                 uint32_t _relative_save_offset;
10844                                 _relative_save_offset = ndr->offset;
10845                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10846                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10847                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10848                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10849                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10850                                 if (ndr->offset > ndr->relative_highest_offset) {
10851                                         ndr->relative_highest_offset = ndr->offset;
10852                                 }
10853                                 ndr->offset = _relative_save_offset;
10854                         }
10855                         ndr->flags = _flags_save_string;
10856                 }
10857                 {
10858                         uint32_t _flags_save_string = ndr->flags;
10859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10860                         if (r->architecture) {
10861                                 uint32_t _relative_save_offset;
10862                                 _relative_save_offset = ndr->offset;
10863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10864                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10865                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10868                                 if (ndr->offset > ndr->relative_highest_offset) {
10869                                         ndr->relative_highest_offset = ndr->offset;
10870                                 }
10871                                 ndr->offset = _relative_save_offset;
10872                         }
10873                         ndr->flags = _flags_save_string;
10874                 }
10875                 {
10876                         uint32_t _flags_save_string = ndr->flags;
10877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10878                         if (r->driver_path) {
10879                                 uint32_t _relative_save_offset;
10880                                 _relative_save_offset = ndr->offset;
10881                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10882                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10883                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10884                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10885                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10886                                 if (ndr->offset > ndr->relative_highest_offset) {
10887                                         ndr->relative_highest_offset = ndr->offset;
10888                                 }
10889                                 ndr->offset = _relative_save_offset;
10890                         }
10891                         ndr->flags = _flags_save_string;
10892                 }
10893                 {
10894                         uint32_t _flags_save_string = ndr->flags;
10895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10896                         if (r->data_file) {
10897                                 uint32_t _relative_save_offset;
10898                                 _relative_save_offset = ndr->offset;
10899                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10900                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10901                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10902                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10903                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10904                                 if (ndr->offset > ndr->relative_highest_offset) {
10905                                         ndr->relative_highest_offset = ndr->offset;
10906                                 }
10907                                 ndr->offset = _relative_save_offset;
10908                         }
10909                         ndr->flags = _flags_save_string;
10910                 }
10911                 {
10912                         uint32_t _flags_save_string = ndr->flags;
10913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10914                         if (r->config_file) {
10915                                 uint32_t _relative_save_offset;
10916                                 _relative_save_offset = ndr->offset;
10917                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10918                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10919                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10920                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10921                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10922                                 if (ndr->offset > ndr->relative_highest_offset) {
10923                                         ndr->relative_highest_offset = ndr->offset;
10924                                 }
10925                                 ndr->offset = _relative_save_offset;
10926                         }
10927                         ndr->flags = _flags_save_string;
10928                 }
10929         }
10930         return NDR_ERR_SUCCESS;
10931 }
10932
10933 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10934 {
10935         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10936         ndr->depth++;
10937         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10938         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10939         ndr->depth++;
10940         if (r->driver_name) {
10941                 ndr_print_string(ndr, "driver_name", r->driver_name);
10942         }
10943         ndr->depth--;
10944         ndr_print_ptr(ndr, "architecture", r->architecture);
10945         ndr->depth++;
10946         if (r->architecture) {
10947                 ndr_print_string(ndr, "architecture", r->architecture);
10948         }
10949         ndr->depth--;
10950         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10951         ndr->depth++;
10952         if (r->driver_path) {
10953                 ndr_print_string(ndr, "driver_path", r->driver_path);
10954         }
10955         ndr->depth--;
10956         ndr_print_ptr(ndr, "data_file", r->data_file);
10957         ndr->depth++;
10958         if (r->data_file) {
10959                 ndr_print_string(ndr, "data_file", r->data_file);
10960         }
10961         ndr->depth--;
10962         ndr_print_ptr(ndr, "config_file", r->config_file);
10963         ndr->depth++;
10964         if (r->config_file) {
10965                 ndr_print_string(ndr, "config_file", r->config_file);
10966         }
10967         ndr->depth--;
10968         ndr->depth--;
10969 }
10970
10971 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10972 {
10973         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10974 }
10975
10976 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10977 {
10978         if (ndr_flags & NDR_SCALARS) {
10979                 NDR_CHECK(ndr_push_align(ndr, 5));
10980                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10981                 {
10982                         uint32_t _flags_save_string = ndr->flags;
10983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10984                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10985                         ndr->flags = _flags_save_string;
10986                 }
10987                 {
10988                         uint32_t _flags_save_string = ndr->flags;
10989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10990                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10991                         ndr->flags = _flags_save_string;
10992                 }
10993                 {
10994                         uint32_t _flags_save_string = ndr->flags;
10995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10996                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10997                         ndr->flags = _flags_save_string;
10998                 }
10999                 {
11000                         uint32_t _flags_save_string = ndr->flags;
11001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11002                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11003                         ndr->flags = _flags_save_string;
11004                 }
11005                 {
11006                         uint32_t _flags_save_string = ndr->flags;
11007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11008                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11009                         ndr->flags = _flags_save_string;
11010                 }
11011                 {
11012                         uint32_t _flags_save_string = ndr->flags;
11013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11014                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11015                         ndr->flags = _flags_save_string;
11016                 }
11017                 {
11018                         uint32_t _flags_save_string_array = ndr->flags;
11019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11020                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11021                         ndr->flags = _flags_save_string_array;
11022                 }
11023                 {
11024                         uint32_t _flags_save_string = ndr->flags;
11025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11026                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11027                         ndr->flags = _flags_save_string;
11028                 }
11029                 {
11030                         uint32_t _flags_save_string = ndr->flags;
11031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11032                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11033                         ndr->flags = _flags_save_string;
11034                 }
11035                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11036         }
11037         if (ndr_flags & NDR_BUFFERS) {
11038                 {
11039                         uint32_t _flags_save_string = ndr->flags;
11040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11041                         if (r->driver_name) {
11042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
11051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11052                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
11060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
11069                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11070                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
11078                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11079                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11080                         }
11081                         ndr->flags = _flags_save_string;
11082                 }
11083                 {
11084                         uint32_t _flags_save_string = ndr->flags;
11085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11086                         if (r->help_file) {
11087                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11088                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11089                         }
11090                         ndr->flags = _flags_save_string;
11091                 }
11092                 {
11093                         uint32_t _flags_save_string_array = ndr->flags;
11094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11095                         if (r->dependent_files) {
11096                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11097                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11098                         }
11099                         ndr->flags = _flags_save_string_array;
11100                 }
11101                 {
11102                         uint32_t _flags_save_string = ndr->flags;
11103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11104                         if (r->monitor_name) {
11105                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11106                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11107                         }
11108                         ndr->flags = _flags_save_string;
11109                 }
11110                 {
11111                         uint32_t _flags_save_string = ndr->flags;
11112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11113                         if (r->default_datatype) {
11114                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11115                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11116                         }
11117                         ndr->flags = _flags_save_string;
11118                 }
11119         }
11120         return NDR_ERR_SUCCESS;
11121 }
11122
11123 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11124 {
11125         uint32_t _ptr_driver_name;
11126         TALLOC_CTX *_mem_save_driver_name_0;
11127         uint32_t _ptr_architecture;
11128         TALLOC_CTX *_mem_save_architecture_0;
11129         uint32_t _ptr_driver_path;
11130         TALLOC_CTX *_mem_save_driver_path_0;
11131         uint32_t _ptr_data_file;
11132         TALLOC_CTX *_mem_save_data_file_0;
11133         uint32_t _ptr_config_file;
11134         TALLOC_CTX *_mem_save_config_file_0;
11135         uint32_t _ptr_help_file;
11136         TALLOC_CTX *_mem_save_help_file_0;
11137         uint32_t _ptr_dependent_files;
11138         TALLOC_CTX *_mem_save_dependent_files_0;
11139         uint32_t _ptr_monitor_name;
11140         TALLOC_CTX *_mem_save_monitor_name_0;
11141         uint32_t _ptr_default_datatype;
11142         TALLOC_CTX *_mem_save_default_datatype_0;
11143         if (ndr_flags & NDR_SCALARS) {
11144                 NDR_CHECK(ndr_pull_align(ndr, 5));
11145                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11146                 {
11147                         uint32_t _flags_save_string = ndr->flags;
11148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11149                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11150                         if (_ptr_driver_name) {
11151                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11152                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11153                         } else {
11154                                 r->driver_name = NULL;
11155                         }
11156                         ndr->flags = _flags_save_string;
11157                 }
11158                 {
11159                         uint32_t _flags_save_string = ndr->flags;
11160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11161                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11162                         if (_ptr_architecture) {
11163                                 NDR_PULL_ALLOC(ndr, r->architecture);
11164                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11165                         } else {
11166                                 r->architecture = NULL;
11167                         }
11168                         ndr->flags = _flags_save_string;
11169                 }
11170                 {
11171                         uint32_t _flags_save_string = ndr->flags;
11172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11173                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11174                         if (_ptr_driver_path) {
11175                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11176                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11177                         } else {
11178                                 r->driver_path = NULL;
11179                         }
11180                         ndr->flags = _flags_save_string;
11181                 }
11182                 {
11183                         uint32_t _flags_save_string = ndr->flags;
11184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11185                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11186                         if (_ptr_data_file) {
11187                                 NDR_PULL_ALLOC(ndr, r->data_file);
11188                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11189                         } else {
11190                                 r->data_file = NULL;
11191                         }
11192                         ndr->flags = _flags_save_string;
11193                 }
11194                 {
11195                         uint32_t _flags_save_string = ndr->flags;
11196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11197                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11198                         if (_ptr_config_file) {
11199                                 NDR_PULL_ALLOC(ndr, r->config_file);
11200                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11201                         } else {
11202                                 r->config_file = NULL;
11203                         }
11204                         ndr->flags = _flags_save_string;
11205                 }
11206                 {
11207                         uint32_t _flags_save_string = ndr->flags;
11208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11209                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11210                         if (_ptr_help_file) {
11211                                 NDR_PULL_ALLOC(ndr, r->help_file);
11212                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11213                         } else {
11214                                 r->help_file = NULL;
11215                         }
11216                         ndr->flags = _flags_save_string;
11217                 }
11218                 {
11219                         uint32_t _flags_save_string_array = ndr->flags;
11220                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11221                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11222                         if (_ptr_dependent_files) {
11223                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11224                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11225                         } else {
11226                                 r->dependent_files = NULL;
11227                         }
11228                         ndr->flags = _flags_save_string_array;
11229                 }
11230                 {
11231                         uint32_t _flags_save_string = ndr->flags;
11232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11233                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11234                         if (_ptr_monitor_name) {
11235                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11236                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11237                         } else {
11238                                 r->monitor_name = NULL;
11239                         }
11240                         ndr->flags = _flags_save_string;
11241                 }
11242                 {
11243                         uint32_t _flags_save_string = ndr->flags;
11244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11245                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11246                         if (_ptr_default_datatype) {
11247                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11248                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11249                         } else {
11250                                 r->default_datatype = NULL;
11251                         }
11252                         ndr->flags = _flags_save_string;
11253                 }
11254                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11255         }
11256         if (ndr_flags & NDR_BUFFERS) {
11257                 {
11258                         uint32_t _flags_save_string = ndr->flags;
11259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11260                         if (r->driver_name) {
11261                                 uint32_t _relative_save_offset;
11262                                 _relative_save_offset = ndr->offset;
11263                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11264                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11265                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11266                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11267                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11268                                 if (ndr->offset > ndr->relative_highest_offset) {
11269                                         ndr->relative_highest_offset = ndr->offset;
11270                                 }
11271                                 ndr->offset = _relative_save_offset;
11272                         }
11273                         ndr->flags = _flags_save_string;
11274                 }
11275                 {
11276                         uint32_t _flags_save_string = ndr->flags;
11277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11278                         if (r->architecture) {
11279                                 uint32_t _relative_save_offset;
11280                                 _relative_save_offset = ndr->offset;
11281                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11282                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11283                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11284                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11285                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11286                                 if (ndr->offset > ndr->relative_highest_offset) {
11287                                         ndr->relative_highest_offset = ndr->offset;
11288                                 }
11289                                 ndr->offset = _relative_save_offset;
11290                         }
11291                         ndr->flags = _flags_save_string;
11292                 }
11293                 {
11294                         uint32_t _flags_save_string = ndr->flags;
11295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11296                         if (r->driver_path) {
11297                                 uint32_t _relative_save_offset;
11298                                 _relative_save_offset = ndr->offset;
11299                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11300                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11301                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11302                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11303                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11304                                 if (ndr->offset > ndr->relative_highest_offset) {
11305                                         ndr->relative_highest_offset = ndr->offset;
11306                                 }
11307                                 ndr->offset = _relative_save_offset;
11308                         }
11309                         ndr->flags = _flags_save_string;
11310                 }
11311                 {
11312                         uint32_t _flags_save_string = ndr->flags;
11313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11314                         if (r->data_file) {
11315                                 uint32_t _relative_save_offset;
11316                                 _relative_save_offset = ndr->offset;
11317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11318                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11319                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11322                                 if (ndr->offset > ndr->relative_highest_offset) {
11323                                         ndr->relative_highest_offset = ndr->offset;
11324                                 }
11325                                 ndr->offset = _relative_save_offset;
11326                         }
11327                         ndr->flags = _flags_save_string;
11328                 }
11329                 {
11330                         uint32_t _flags_save_string = ndr->flags;
11331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11332                         if (r->config_file) {
11333                                 uint32_t _relative_save_offset;
11334                                 _relative_save_offset = ndr->offset;
11335                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11336                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11337                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11338                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11339                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11340                                 if (ndr->offset > ndr->relative_highest_offset) {
11341                                         ndr->relative_highest_offset = ndr->offset;
11342                                 }
11343                                 ndr->offset = _relative_save_offset;
11344                         }
11345                         ndr->flags = _flags_save_string;
11346                 }
11347                 {
11348                         uint32_t _flags_save_string = ndr->flags;
11349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11350                         if (r->help_file) {
11351                                 uint32_t _relative_save_offset;
11352                                 _relative_save_offset = ndr->offset;
11353                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11354                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11355                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11356                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11357                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11358                                 if (ndr->offset > ndr->relative_highest_offset) {
11359                                         ndr->relative_highest_offset = ndr->offset;
11360                                 }
11361                                 ndr->offset = _relative_save_offset;
11362                         }
11363                         ndr->flags = _flags_save_string;
11364                 }
11365                 {
11366                         uint32_t _flags_save_string_array = ndr->flags;
11367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11368                         if (r->dependent_files) {
11369                                 uint32_t _relative_save_offset;
11370                                 _relative_save_offset = ndr->offset;
11371                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11372                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11373                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11374                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11375                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11376                                 if (ndr->offset > ndr->relative_highest_offset) {
11377                                         ndr->relative_highest_offset = ndr->offset;
11378                                 }
11379                                 ndr->offset = _relative_save_offset;
11380                         }
11381                         ndr->flags = _flags_save_string_array;
11382                 }
11383                 {
11384                         uint32_t _flags_save_string = ndr->flags;
11385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11386                         if (r->monitor_name) {
11387                                 uint32_t _relative_save_offset;
11388                                 _relative_save_offset = ndr->offset;
11389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11390                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11391                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11392                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11393                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11394                                 if (ndr->offset > ndr->relative_highest_offset) {
11395                                         ndr->relative_highest_offset = ndr->offset;
11396                                 }
11397                                 ndr->offset = _relative_save_offset;
11398                         }
11399                         ndr->flags = _flags_save_string;
11400                 }
11401                 {
11402                         uint32_t _flags_save_string = ndr->flags;
11403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11404                         if (r->default_datatype) {
11405                                 uint32_t _relative_save_offset;
11406                                 _relative_save_offset = ndr->offset;
11407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11408                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11409                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11410                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11412                                 if (ndr->offset > ndr->relative_highest_offset) {
11413                                         ndr->relative_highest_offset = ndr->offset;
11414                                 }
11415                                 ndr->offset = _relative_save_offset;
11416                         }
11417                         ndr->flags = _flags_save_string;
11418                 }
11419         }
11420         return NDR_ERR_SUCCESS;
11421 }
11422
11423 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11424 {
11425         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11426         ndr->depth++;
11427         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11428         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11429         ndr->depth++;
11430         if (r->driver_name) {
11431                 ndr_print_string(ndr, "driver_name", r->driver_name);
11432         }
11433         ndr->depth--;
11434         ndr_print_ptr(ndr, "architecture", r->architecture);
11435         ndr->depth++;
11436         if (r->architecture) {
11437                 ndr_print_string(ndr, "architecture", r->architecture);
11438         }
11439         ndr->depth--;
11440         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11441         ndr->depth++;
11442         if (r->driver_path) {
11443                 ndr_print_string(ndr, "driver_path", r->driver_path);
11444         }
11445         ndr->depth--;
11446         ndr_print_ptr(ndr, "data_file", r->data_file);
11447         ndr->depth++;
11448         if (r->data_file) {
11449                 ndr_print_string(ndr, "data_file", r->data_file);
11450         }
11451         ndr->depth--;
11452         ndr_print_ptr(ndr, "config_file", r->config_file);
11453         ndr->depth++;
11454         if (r->config_file) {
11455                 ndr_print_string(ndr, "config_file", r->config_file);
11456         }
11457         ndr->depth--;
11458         ndr_print_ptr(ndr, "help_file", r->help_file);
11459         ndr->depth++;
11460         if (r->help_file) {
11461                 ndr_print_string(ndr, "help_file", r->help_file);
11462         }
11463         ndr->depth--;
11464         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11465         ndr->depth++;
11466         if (r->dependent_files) {
11467                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11468         }
11469         ndr->depth--;
11470         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11471         ndr->depth++;
11472         if (r->monitor_name) {
11473                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11474         }
11475         ndr->depth--;
11476         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11477         ndr->depth++;
11478         if (r->default_datatype) {
11479                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11480         }
11481         ndr->depth--;
11482         ndr->depth--;
11483 }
11484
11485 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11486 {
11487         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11488 }
11489
11490 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11491 {
11492         if (ndr_flags & NDR_SCALARS) {
11493                 NDR_CHECK(ndr_push_align(ndr, 5));
11494                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11495                 {
11496                         uint32_t _flags_save_string = ndr->flags;
11497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11499                         ndr->flags = _flags_save_string;
11500                 }
11501                 {
11502                         uint32_t _flags_save_string = ndr->flags;
11503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11505                         ndr->flags = _flags_save_string;
11506                 }
11507                 {
11508                         uint32_t _flags_save_string = ndr->flags;
11509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11511                         ndr->flags = _flags_save_string;
11512                 }
11513                 {
11514                         uint32_t _flags_save_string = ndr->flags;
11515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11516                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11517                         ndr->flags = _flags_save_string;
11518                 }
11519                 {
11520                         uint32_t _flags_save_string = ndr->flags;
11521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11522                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11523                         ndr->flags = _flags_save_string;
11524                 }
11525                 {
11526                         uint32_t _flags_save_string = ndr->flags;
11527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11528                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11529                         ndr->flags = _flags_save_string;
11530                 }
11531                 {
11532                         uint32_t _flags_save_string_array = ndr->flags;
11533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11534                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11535                         ndr->flags = _flags_save_string_array;
11536                 }
11537                 {
11538                         uint32_t _flags_save_string = ndr->flags;
11539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11540                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11541                         ndr->flags = _flags_save_string;
11542                 }
11543                 {
11544                         uint32_t _flags_save_string = ndr->flags;
11545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11546                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11547                         ndr->flags = _flags_save_string;
11548                 }
11549                 {
11550                         uint32_t _flags_save_string_array = ndr->flags;
11551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11552                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11553                         ndr->flags = _flags_save_string_array;
11554                 }
11555                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11556         }
11557         if (ndr_flags & NDR_BUFFERS) {
11558                 {
11559                         uint32_t _flags_save_string = ndr->flags;
11560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11561                         if (r->driver_name) {
11562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
11571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
11580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
11589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
11598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11600                         }
11601                         ndr->flags = _flags_save_string;
11602                 }
11603                 {
11604                         uint32_t _flags_save_string = ndr->flags;
11605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11606                         if (r->help_file) {
11607                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11608                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11609                         }
11610                         ndr->flags = _flags_save_string;
11611                 }
11612                 {
11613                         uint32_t _flags_save_string_array = ndr->flags;
11614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11615                         if (r->dependent_files) {
11616                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11617                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11618                         }
11619                         ndr->flags = _flags_save_string_array;
11620                 }
11621                 {
11622                         uint32_t _flags_save_string = ndr->flags;
11623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11624                         if (r->monitor_name) {
11625                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11626                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11627                         }
11628                         ndr->flags = _flags_save_string;
11629                 }
11630                 {
11631                         uint32_t _flags_save_string = ndr->flags;
11632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11633                         if (r->default_datatype) {
11634                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11635                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11636                         }
11637                         ndr->flags = _flags_save_string;
11638                 }
11639                 {
11640                         uint32_t _flags_save_string_array = ndr->flags;
11641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11642                         if (r->previous_names) {
11643                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11644                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11645                         }
11646                         ndr->flags = _flags_save_string_array;
11647                 }
11648         }
11649         return NDR_ERR_SUCCESS;
11650 }
11651
11652 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11653 {
11654         uint32_t _ptr_driver_name;
11655         TALLOC_CTX *_mem_save_driver_name_0;
11656         uint32_t _ptr_architecture;
11657         TALLOC_CTX *_mem_save_architecture_0;
11658         uint32_t _ptr_driver_path;
11659         TALLOC_CTX *_mem_save_driver_path_0;
11660         uint32_t _ptr_data_file;
11661         TALLOC_CTX *_mem_save_data_file_0;
11662         uint32_t _ptr_config_file;
11663         TALLOC_CTX *_mem_save_config_file_0;
11664         uint32_t _ptr_help_file;
11665         TALLOC_CTX *_mem_save_help_file_0;
11666         uint32_t _ptr_dependent_files;
11667         TALLOC_CTX *_mem_save_dependent_files_0;
11668         uint32_t _ptr_monitor_name;
11669         TALLOC_CTX *_mem_save_monitor_name_0;
11670         uint32_t _ptr_default_datatype;
11671         TALLOC_CTX *_mem_save_default_datatype_0;
11672         uint32_t _ptr_previous_names;
11673         TALLOC_CTX *_mem_save_previous_names_0;
11674         if (ndr_flags & NDR_SCALARS) {
11675                 NDR_CHECK(ndr_pull_align(ndr, 5));
11676                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11677                 {
11678                         uint32_t _flags_save_string = ndr->flags;
11679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11681                         if (_ptr_driver_name) {
11682                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11684                         } else {
11685                                 r->driver_name = NULL;
11686                         }
11687                         ndr->flags = _flags_save_string;
11688                 }
11689                 {
11690                         uint32_t _flags_save_string = ndr->flags;
11691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11692                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11693                         if (_ptr_architecture) {
11694                                 NDR_PULL_ALLOC(ndr, r->architecture);
11695                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11696                         } else {
11697                                 r->architecture = NULL;
11698                         }
11699                         ndr->flags = _flags_save_string;
11700                 }
11701                 {
11702                         uint32_t _flags_save_string = ndr->flags;
11703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11704                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11705                         if (_ptr_driver_path) {
11706                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11707                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11708                         } else {
11709                                 r->driver_path = NULL;
11710                         }
11711                         ndr->flags = _flags_save_string;
11712                 }
11713                 {
11714                         uint32_t _flags_save_string = ndr->flags;
11715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11716                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11717                         if (_ptr_data_file) {
11718                                 NDR_PULL_ALLOC(ndr, r->data_file);
11719                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11720                         } else {
11721                                 r->data_file = NULL;
11722                         }
11723                         ndr->flags = _flags_save_string;
11724                 }
11725                 {
11726                         uint32_t _flags_save_string = ndr->flags;
11727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11728                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11729                         if (_ptr_config_file) {
11730                                 NDR_PULL_ALLOC(ndr, r->config_file);
11731                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11732                         } else {
11733                                 r->config_file = NULL;
11734                         }
11735                         ndr->flags = _flags_save_string;
11736                 }
11737                 {
11738                         uint32_t _flags_save_string = ndr->flags;
11739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11740                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11741                         if (_ptr_help_file) {
11742                                 NDR_PULL_ALLOC(ndr, r->help_file);
11743                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11744                         } else {
11745                                 r->help_file = NULL;
11746                         }
11747                         ndr->flags = _flags_save_string;
11748                 }
11749                 {
11750                         uint32_t _flags_save_string_array = ndr->flags;
11751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11752                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11753                         if (_ptr_dependent_files) {
11754                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11755                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11756                         } else {
11757                                 r->dependent_files = NULL;
11758                         }
11759                         ndr->flags = _flags_save_string_array;
11760                 }
11761                 {
11762                         uint32_t _flags_save_string = ndr->flags;
11763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11764                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11765                         if (_ptr_monitor_name) {
11766                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11767                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11768                         } else {
11769                                 r->monitor_name = NULL;
11770                         }
11771                         ndr->flags = _flags_save_string;
11772                 }
11773                 {
11774                         uint32_t _flags_save_string = ndr->flags;
11775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11777                         if (_ptr_default_datatype) {
11778                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11780                         } else {
11781                                 r->default_datatype = NULL;
11782                         }
11783                         ndr->flags = _flags_save_string;
11784                 }
11785                 {
11786                         uint32_t _flags_save_string_array = ndr->flags;
11787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11788                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11789                         if (_ptr_previous_names) {
11790                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11791                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11792                         } else {
11793                                 r->previous_names = NULL;
11794                         }
11795                         ndr->flags = _flags_save_string_array;
11796                 }
11797                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11798         }
11799         if (ndr_flags & NDR_BUFFERS) {
11800                 {
11801                         uint32_t _flags_save_string = ndr->flags;
11802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11803                         if (r->driver_name) {
11804                                 uint32_t _relative_save_offset;
11805                                 _relative_save_offset = ndr->offset;
11806                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11807                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11808                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11809                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11810                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11811                                 if (ndr->offset > ndr->relative_highest_offset) {
11812                                         ndr->relative_highest_offset = ndr->offset;
11813                                 }
11814                                 ndr->offset = _relative_save_offset;
11815                         }
11816                         ndr->flags = _flags_save_string;
11817                 }
11818                 {
11819                         uint32_t _flags_save_string = ndr->flags;
11820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11821                         if (r->architecture) {
11822                                 uint32_t _relative_save_offset;
11823                                 _relative_save_offset = ndr->offset;
11824                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11825                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11826                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11827                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11828                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11829                                 if (ndr->offset > ndr->relative_highest_offset) {
11830                                         ndr->relative_highest_offset = ndr->offset;
11831                                 }
11832                                 ndr->offset = _relative_save_offset;
11833                         }
11834                         ndr->flags = _flags_save_string;
11835                 }
11836                 {
11837                         uint32_t _flags_save_string = ndr->flags;
11838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11839                         if (r->driver_path) {
11840                                 uint32_t _relative_save_offset;
11841                                 _relative_save_offset = ndr->offset;
11842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11843                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11844                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11847                                 if (ndr->offset > ndr->relative_highest_offset) {
11848                                         ndr->relative_highest_offset = ndr->offset;
11849                                 }
11850                                 ndr->offset = _relative_save_offset;
11851                         }
11852                         ndr->flags = _flags_save_string;
11853                 }
11854                 {
11855                         uint32_t _flags_save_string = ndr->flags;
11856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11857                         if (r->data_file) {
11858                                 uint32_t _relative_save_offset;
11859                                 _relative_save_offset = ndr->offset;
11860                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11861                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11862                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11863                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11864                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11865                                 if (ndr->offset > ndr->relative_highest_offset) {
11866                                         ndr->relative_highest_offset = ndr->offset;
11867                                 }
11868                                 ndr->offset = _relative_save_offset;
11869                         }
11870                         ndr->flags = _flags_save_string;
11871                 }
11872                 {
11873                         uint32_t _flags_save_string = ndr->flags;
11874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11875                         if (r->config_file) {
11876                                 uint32_t _relative_save_offset;
11877                                 _relative_save_offset = ndr->offset;
11878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11879                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11880                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11883                                 if (ndr->offset > ndr->relative_highest_offset) {
11884                                         ndr->relative_highest_offset = ndr->offset;
11885                                 }
11886                                 ndr->offset = _relative_save_offset;
11887                         }
11888                         ndr->flags = _flags_save_string;
11889                 }
11890                 {
11891                         uint32_t _flags_save_string = ndr->flags;
11892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11893                         if (r->help_file) {
11894                                 uint32_t _relative_save_offset;
11895                                 _relative_save_offset = ndr->offset;
11896                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11897                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11898                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11899                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11900                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11901                                 if (ndr->offset > ndr->relative_highest_offset) {
11902                                         ndr->relative_highest_offset = ndr->offset;
11903                                 }
11904                                 ndr->offset = _relative_save_offset;
11905                         }
11906                         ndr->flags = _flags_save_string;
11907                 }
11908                 {
11909                         uint32_t _flags_save_string_array = ndr->flags;
11910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11911                         if (r->dependent_files) {
11912                                 uint32_t _relative_save_offset;
11913                                 _relative_save_offset = ndr->offset;
11914                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11915                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11916                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11917                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11918                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11919                                 if (ndr->offset > ndr->relative_highest_offset) {
11920                                         ndr->relative_highest_offset = ndr->offset;
11921                                 }
11922                                 ndr->offset = _relative_save_offset;
11923                         }
11924                         ndr->flags = _flags_save_string_array;
11925                 }
11926                 {
11927                         uint32_t _flags_save_string = ndr->flags;
11928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11929                         if (r->monitor_name) {
11930                                 uint32_t _relative_save_offset;
11931                                 _relative_save_offset = ndr->offset;
11932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11933                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11934                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11937                                 if (ndr->offset > ndr->relative_highest_offset) {
11938                                         ndr->relative_highest_offset = ndr->offset;
11939                                 }
11940                                 ndr->offset = _relative_save_offset;
11941                         }
11942                         ndr->flags = _flags_save_string;
11943                 }
11944                 {
11945                         uint32_t _flags_save_string = ndr->flags;
11946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11947                         if (r->default_datatype) {
11948                                 uint32_t _relative_save_offset;
11949                                 _relative_save_offset = ndr->offset;
11950                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11951                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11952                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11953                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11954                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11955                                 if (ndr->offset > ndr->relative_highest_offset) {
11956                                         ndr->relative_highest_offset = ndr->offset;
11957                                 }
11958                                 ndr->offset = _relative_save_offset;
11959                         }
11960                         ndr->flags = _flags_save_string;
11961                 }
11962                 {
11963                         uint32_t _flags_save_string_array = ndr->flags;
11964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11965                         if (r->previous_names) {
11966                                 uint32_t _relative_save_offset;
11967                                 _relative_save_offset = ndr->offset;
11968                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11969                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11970                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11971                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11972                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11973                                 if (ndr->offset > ndr->relative_highest_offset) {
11974                                         ndr->relative_highest_offset = ndr->offset;
11975                                 }
11976                                 ndr->offset = _relative_save_offset;
11977                         }
11978                         ndr->flags = _flags_save_string_array;
11979                 }
11980         }
11981         return NDR_ERR_SUCCESS;
11982 }
11983
11984 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11985 {
11986         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11987         ndr->depth++;
11988         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11989         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11990         ndr->depth++;
11991         if (r->driver_name) {
11992                 ndr_print_string(ndr, "driver_name", r->driver_name);
11993         }
11994         ndr->depth--;
11995         ndr_print_ptr(ndr, "architecture", r->architecture);
11996         ndr->depth++;
11997         if (r->architecture) {
11998                 ndr_print_string(ndr, "architecture", r->architecture);
11999         }
12000         ndr->depth--;
12001         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12002         ndr->depth++;
12003         if (r->driver_path) {
12004                 ndr_print_string(ndr, "driver_path", r->driver_path);
12005         }
12006         ndr->depth--;
12007         ndr_print_ptr(ndr, "data_file", r->data_file);
12008         ndr->depth++;
12009         if (r->data_file) {
12010                 ndr_print_string(ndr, "data_file", r->data_file);
12011         }
12012         ndr->depth--;
12013         ndr_print_ptr(ndr, "config_file", r->config_file);
12014         ndr->depth++;
12015         if (r->config_file) {
12016                 ndr_print_string(ndr, "config_file", r->config_file);
12017         }
12018         ndr->depth--;
12019         ndr_print_ptr(ndr, "help_file", r->help_file);
12020         ndr->depth++;
12021         if (r->help_file) {
12022                 ndr_print_string(ndr, "help_file", r->help_file);
12023         }
12024         ndr->depth--;
12025         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12026         ndr->depth++;
12027         if (r->dependent_files) {
12028                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12029         }
12030         ndr->depth--;
12031         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12032         ndr->depth++;
12033         if (r->monitor_name) {
12034                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12035         }
12036         ndr->depth--;
12037         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12038         ndr->depth++;
12039         if (r->default_datatype) {
12040                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12041         }
12042         ndr->depth--;
12043         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12044         ndr->depth++;
12045         if (r->previous_names) {
12046                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12047         }
12048         ndr->depth--;
12049         ndr->depth--;
12050 }
12051
12052 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12053 {
12054         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12055 }
12056
12057 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12058 {
12059         if (ndr_flags & NDR_SCALARS) {
12060                 NDR_CHECK(ndr_push_align(ndr, 5));
12061                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12062                 {
12063                         uint32_t _flags_save_string = ndr->flags;
12064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12065                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12066                         ndr->flags = _flags_save_string;
12067                 }
12068                 {
12069                         uint32_t _flags_save_string = ndr->flags;
12070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12071                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12072                         ndr->flags = _flags_save_string;
12073                 }
12074                 {
12075                         uint32_t _flags_save_string = ndr->flags;
12076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12077                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12078                         ndr->flags = _flags_save_string;
12079                 }
12080                 {
12081                         uint32_t _flags_save_string = ndr->flags;
12082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12083                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12084                         ndr->flags = _flags_save_string;
12085                 }
12086                 {
12087                         uint32_t _flags_save_string = ndr->flags;
12088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12089                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12090                         ndr->flags = _flags_save_string;
12091                 }
12092                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12095                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12096         }
12097         if (ndr_flags & NDR_BUFFERS) {
12098                 {
12099                         uint32_t _flags_save_string = ndr->flags;
12100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12101                         if (r->driver_name) {
12102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
12111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
12120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
12129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12131                         }
12132                         ndr->flags = _flags_save_string;
12133                 }
12134                 {
12135                         uint32_t _flags_save_string = ndr->flags;
12136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12137                         if (r->config_file) {
12138                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12139                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12140                         }
12141                         ndr->flags = _flags_save_string;
12142                 }
12143         }
12144         return NDR_ERR_SUCCESS;
12145 }
12146
12147 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12148 {
12149         uint32_t _ptr_driver_name;
12150         TALLOC_CTX *_mem_save_driver_name_0;
12151         uint32_t _ptr_architecture;
12152         TALLOC_CTX *_mem_save_architecture_0;
12153         uint32_t _ptr_driver_path;
12154         TALLOC_CTX *_mem_save_driver_path_0;
12155         uint32_t _ptr_data_file;
12156         TALLOC_CTX *_mem_save_data_file_0;
12157         uint32_t _ptr_config_file;
12158         TALLOC_CTX *_mem_save_config_file_0;
12159         if (ndr_flags & NDR_SCALARS) {
12160                 NDR_CHECK(ndr_pull_align(ndr, 5));
12161                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12162                 {
12163                         uint32_t _flags_save_string = ndr->flags;
12164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12165                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12166                         if (_ptr_driver_name) {
12167                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12168                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12169                         } else {
12170                                 r->driver_name = NULL;
12171                         }
12172                         ndr->flags = _flags_save_string;
12173                 }
12174                 {
12175                         uint32_t _flags_save_string = ndr->flags;
12176                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12177                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12178                         if (_ptr_architecture) {
12179                                 NDR_PULL_ALLOC(ndr, r->architecture);
12180                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12181                         } else {
12182                                 r->architecture = NULL;
12183                         }
12184                         ndr->flags = _flags_save_string;
12185                 }
12186                 {
12187                         uint32_t _flags_save_string = ndr->flags;
12188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12189                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12190                         if (_ptr_driver_path) {
12191                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12192                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12193                         } else {
12194                                 r->driver_path = NULL;
12195                         }
12196                         ndr->flags = _flags_save_string;
12197                 }
12198                 {
12199                         uint32_t _flags_save_string = ndr->flags;
12200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12201                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12202                         if (_ptr_data_file) {
12203                                 NDR_PULL_ALLOC(ndr, r->data_file);
12204                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12205                         } else {
12206                                 r->data_file = NULL;
12207                         }
12208                         ndr->flags = _flags_save_string;
12209                 }
12210                 {
12211                         uint32_t _flags_save_string = ndr->flags;
12212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12213                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12214                         if (_ptr_config_file) {
12215                                 NDR_PULL_ALLOC(ndr, r->config_file);
12216                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12217                         } else {
12218                                 r->config_file = NULL;
12219                         }
12220                         ndr->flags = _flags_save_string;
12221                 }
12222                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12225                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12226         }
12227         if (ndr_flags & NDR_BUFFERS) {
12228                 {
12229                         uint32_t _flags_save_string = ndr->flags;
12230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12231                         if (r->driver_name) {
12232                                 uint32_t _relative_save_offset;
12233                                 _relative_save_offset = ndr->offset;
12234                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12235                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12236                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12237                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12238                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12239                                 if (ndr->offset > ndr->relative_highest_offset) {
12240                                         ndr->relative_highest_offset = ndr->offset;
12241                                 }
12242                                 ndr->offset = _relative_save_offset;
12243                         }
12244                         ndr->flags = _flags_save_string;
12245                 }
12246                 {
12247                         uint32_t _flags_save_string = ndr->flags;
12248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12249                         if (r->architecture) {
12250                                 uint32_t _relative_save_offset;
12251                                 _relative_save_offset = ndr->offset;
12252                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12253                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12254                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12255                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12256                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12257                                 if (ndr->offset > ndr->relative_highest_offset) {
12258                                         ndr->relative_highest_offset = ndr->offset;
12259                                 }
12260                                 ndr->offset = _relative_save_offset;
12261                         }
12262                         ndr->flags = _flags_save_string;
12263                 }
12264                 {
12265                         uint32_t _flags_save_string = ndr->flags;
12266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12267                         if (r->driver_path) {
12268                                 uint32_t _relative_save_offset;
12269                                 _relative_save_offset = ndr->offset;
12270                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12271                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12272                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12273                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12274                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12275                                 if (ndr->offset > ndr->relative_highest_offset) {
12276                                         ndr->relative_highest_offset = ndr->offset;
12277                                 }
12278                                 ndr->offset = _relative_save_offset;
12279                         }
12280                         ndr->flags = _flags_save_string;
12281                 }
12282                 {
12283                         uint32_t _flags_save_string = ndr->flags;
12284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12285                         if (r->data_file) {
12286                                 uint32_t _relative_save_offset;
12287                                 _relative_save_offset = ndr->offset;
12288                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12289                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12290                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12291                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12292                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12293                                 if (ndr->offset > ndr->relative_highest_offset) {
12294                                         ndr->relative_highest_offset = ndr->offset;
12295                                 }
12296                                 ndr->offset = _relative_save_offset;
12297                         }
12298                         ndr->flags = _flags_save_string;
12299                 }
12300                 {
12301                         uint32_t _flags_save_string = ndr->flags;
12302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12303                         if (r->config_file) {
12304                                 uint32_t _relative_save_offset;
12305                                 _relative_save_offset = ndr->offset;
12306                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12307                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12308                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12309                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12310                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12311                                 if (ndr->offset > ndr->relative_highest_offset) {
12312                                         ndr->relative_highest_offset = ndr->offset;
12313                                 }
12314                                 ndr->offset = _relative_save_offset;
12315                         }
12316                         ndr->flags = _flags_save_string;
12317                 }
12318         }
12319         return NDR_ERR_SUCCESS;
12320 }
12321
12322 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12323 {
12324         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12325         ndr->depth++;
12326         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12327         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12328         ndr->depth++;
12329         if (r->driver_name) {
12330                 ndr_print_string(ndr, "driver_name", r->driver_name);
12331         }
12332         ndr->depth--;
12333         ndr_print_ptr(ndr, "architecture", r->architecture);
12334         ndr->depth++;
12335         if (r->architecture) {
12336                 ndr_print_string(ndr, "architecture", r->architecture);
12337         }
12338         ndr->depth--;
12339         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12340         ndr->depth++;
12341         if (r->driver_path) {
12342                 ndr_print_string(ndr, "driver_path", r->driver_path);
12343         }
12344         ndr->depth--;
12345         ndr_print_ptr(ndr, "data_file", r->data_file);
12346         ndr->depth++;
12347         if (r->data_file) {
12348                 ndr_print_string(ndr, "data_file", r->data_file);
12349         }
12350         ndr->depth--;
12351         ndr_print_ptr(ndr, "config_file", r->config_file);
12352         ndr->depth++;
12353         if (r->config_file) {
12354                 ndr_print_string(ndr, "config_file", r->config_file);
12355         }
12356         ndr->depth--;
12357         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12358         ndr_print_uint32(ndr, "config_version", r->config_version);
12359         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12360         ndr->depth--;
12361 }
12362
12363 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12364 {
12365         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12366 }
12367
12368 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12369 {
12370         if (ndr_flags & NDR_SCALARS) {
12371                 NDR_CHECK(ndr_push_align(ndr, 8));
12372                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12373                 {
12374                         uint32_t _flags_save_string = ndr->flags;
12375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12376                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12377                         ndr->flags = _flags_save_string;
12378                 }
12379                 {
12380                         uint32_t _flags_save_string = ndr->flags;
12381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12382                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12383                         ndr->flags = _flags_save_string;
12384                 }
12385                 {
12386                         uint32_t _flags_save_string = ndr->flags;
12387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12388                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12389                         ndr->flags = _flags_save_string;
12390                 }
12391                 {
12392                         uint32_t _flags_save_string = ndr->flags;
12393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12394                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12395                         ndr->flags = _flags_save_string;
12396                 }
12397                 {
12398                         uint32_t _flags_save_string = ndr->flags;
12399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12400                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12401                         ndr->flags = _flags_save_string;
12402                 }
12403                 {
12404                         uint32_t _flags_save_string = ndr->flags;
12405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12406                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12407                         ndr->flags = _flags_save_string;
12408                 }
12409                 {
12410                         uint32_t _flags_save_string_array = ndr->flags;
12411                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12412                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12413                         ndr->flags = _flags_save_string_array;
12414                 }
12415                 {
12416                         uint32_t _flags_save_string = ndr->flags;
12417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12418                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12419                         ndr->flags = _flags_save_string;
12420                 }
12421                 {
12422                         uint32_t _flags_save_string = ndr->flags;
12423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12424                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12425                         ndr->flags = _flags_save_string;
12426                 }
12427                 {
12428                         uint32_t _flags_save_string_array = ndr->flags;
12429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12430                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12431                         ndr->flags = _flags_save_string_array;
12432                 }
12433                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12434                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12435                 {
12436                         uint32_t _flags_save_string = ndr->flags;
12437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12438                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12439                         ndr->flags = _flags_save_string;
12440                 }
12441                 {
12442                         uint32_t _flags_save_string = ndr->flags;
12443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12444                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12445                         ndr->flags = _flags_save_string;
12446                 }
12447                 {
12448                         uint32_t _flags_save_string = ndr->flags;
12449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12450                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12451                         ndr->flags = _flags_save_string;
12452                 }
12453                 {
12454                         uint32_t _flags_save_string = ndr->flags;
12455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12456                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12457                         ndr->flags = _flags_save_string;
12458                 }
12459                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12460         }
12461         if (ndr_flags & NDR_BUFFERS) {
12462                 {
12463                         uint32_t _flags_save_string = ndr->flags;
12464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12465                         if (r->driver_name) {
12466                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12467                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
12475                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12476                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
12484                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12485                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
12493                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12494                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
12502                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12503                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12504                         }
12505                         ndr->flags = _flags_save_string;
12506                 }
12507                 {
12508                         uint32_t _flags_save_string = ndr->flags;
12509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12510                         if (r->help_file) {
12511                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12512                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12513                         }
12514                         ndr->flags = _flags_save_string;
12515                 }
12516                 {
12517                         uint32_t _flags_save_string_array = ndr->flags;
12518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12519                         if (r->dependent_files) {
12520                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12521                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12522                         }
12523                         ndr->flags = _flags_save_string_array;
12524                 }
12525                 {
12526                         uint32_t _flags_save_string = ndr->flags;
12527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12528                         if (r->monitor_name) {
12529                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12530                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12531                         }
12532                         ndr->flags = _flags_save_string;
12533                 }
12534                 {
12535                         uint32_t _flags_save_string = ndr->flags;
12536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12537                         if (r->default_datatype) {
12538                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12539                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12540                         }
12541                         ndr->flags = _flags_save_string;
12542                 }
12543                 {
12544                         uint32_t _flags_save_string_array = ndr->flags;
12545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12546                         if (r->previous_names) {
12547                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12548                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12549                         }
12550                         ndr->flags = _flags_save_string_array;
12551                 }
12552                 {
12553                         uint32_t _flags_save_string = ndr->flags;
12554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12555                         if (r->manufacturer_name) {
12556                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12557                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
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->manufacturer_url) {
12565                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12566                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
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->hardware_id) {
12574                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12575                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12576                         }
12577                         ndr->flags = _flags_save_string;
12578                 }
12579                 {
12580                         uint32_t _flags_save_string = ndr->flags;
12581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12582                         if (r->provider) {
12583                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12584                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12585                         }
12586                         ndr->flags = _flags_save_string;
12587                 }
12588         }
12589         return NDR_ERR_SUCCESS;
12590 }
12591
12592 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12593 {
12594         uint32_t _ptr_driver_name;
12595         TALLOC_CTX *_mem_save_driver_name_0;
12596         uint32_t _ptr_architecture;
12597         TALLOC_CTX *_mem_save_architecture_0;
12598         uint32_t _ptr_driver_path;
12599         TALLOC_CTX *_mem_save_driver_path_0;
12600         uint32_t _ptr_data_file;
12601         TALLOC_CTX *_mem_save_data_file_0;
12602         uint32_t _ptr_config_file;
12603         TALLOC_CTX *_mem_save_config_file_0;
12604         uint32_t _ptr_help_file;
12605         TALLOC_CTX *_mem_save_help_file_0;
12606         uint32_t _ptr_dependent_files;
12607         TALLOC_CTX *_mem_save_dependent_files_0;
12608         uint32_t _ptr_monitor_name;
12609         TALLOC_CTX *_mem_save_monitor_name_0;
12610         uint32_t _ptr_default_datatype;
12611         TALLOC_CTX *_mem_save_default_datatype_0;
12612         uint32_t _ptr_previous_names;
12613         TALLOC_CTX *_mem_save_previous_names_0;
12614         uint32_t _ptr_manufacturer_name;
12615         TALLOC_CTX *_mem_save_manufacturer_name_0;
12616         uint32_t _ptr_manufacturer_url;
12617         TALLOC_CTX *_mem_save_manufacturer_url_0;
12618         uint32_t _ptr_hardware_id;
12619         TALLOC_CTX *_mem_save_hardware_id_0;
12620         uint32_t _ptr_provider;
12621         TALLOC_CTX *_mem_save_provider_0;
12622         if (ndr_flags & NDR_SCALARS) {
12623                 NDR_CHECK(ndr_pull_align(ndr, 8));
12624                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12625                 {
12626                         uint32_t _flags_save_string = ndr->flags;
12627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12628                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12629                         if (_ptr_driver_name) {
12630                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12631                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12632                         } else {
12633                                 r->driver_name = NULL;
12634                         }
12635                         ndr->flags = _flags_save_string;
12636                 }
12637                 {
12638                         uint32_t _flags_save_string = ndr->flags;
12639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12640                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12641                         if (_ptr_architecture) {
12642                                 NDR_PULL_ALLOC(ndr, r->architecture);
12643                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12644                         } else {
12645                                 r->architecture = NULL;
12646                         }
12647                         ndr->flags = _flags_save_string;
12648                 }
12649                 {
12650                         uint32_t _flags_save_string = ndr->flags;
12651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12652                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12653                         if (_ptr_driver_path) {
12654                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12655                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12656                         } else {
12657                                 r->driver_path = NULL;
12658                         }
12659                         ndr->flags = _flags_save_string;
12660                 }
12661                 {
12662                         uint32_t _flags_save_string = ndr->flags;
12663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12665                         if (_ptr_data_file) {
12666                                 NDR_PULL_ALLOC(ndr, r->data_file);
12667                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12668                         } else {
12669                                 r->data_file = NULL;
12670                         }
12671                         ndr->flags = _flags_save_string;
12672                 }
12673                 {
12674                         uint32_t _flags_save_string = ndr->flags;
12675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12676                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12677                         if (_ptr_config_file) {
12678                                 NDR_PULL_ALLOC(ndr, r->config_file);
12679                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12680                         } else {
12681                                 r->config_file = NULL;
12682                         }
12683                         ndr->flags = _flags_save_string;
12684                 }
12685                 {
12686                         uint32_t _flags_save_string = ndr->flags;
12687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12688                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12689                         if (_ptr_help_file) {
12690                                 NDR_PULL_ALLOC(ndr, r->help_file);
12691                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12692                         } else {
12693                                 r->help_file = NULL;
12694                         }
12695                         ndr->flags = _flags_save_string;
12696                 }
12697                 {
12698                         uint32_t _flags_save_string_array = ndr->flags;
12699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12700                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12701                         if (_ptr_dependent_files) {
12702                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12703                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12704                         } else {
12705                                 r->dependent_files = NULL;
12706                         }
12707                         ndr->flags = _flags_save_string_array;
12708                 }
12709                 {
12710                         uint32_t _flags_save_string = ndr->flags;
12711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12712                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12713                         if (_ptr_monitor_name) {
12714                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12715                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12716                         } else {
12717                                 r->monitor_name = NULL;
12718                         }
12719                         ndr->flags = _flags_save_string;
12720                 }
12721                 {
12722                         uint32_t _flags_save_string = ndr->flags;
12723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12724                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12725                         if (_ptr_default_datatype) {
12726                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12727                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12728                         } else {
12729                                 r->default_datatype = NULL;
12730                         }
12731                         ndr->flags = _flags_save_string;
12732                 }
12733                 {
12734                         uint32_t _flags_save_string_array = ndr->flags;
12735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12736                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12737                         if (_ptr_previous_names) {
12738                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12739                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12740                         } else {
12741                                 r->previous_names = NULL;
12742                         }
12743                         ndr->flags = _flags_save_string_array;
12744                 }
12745                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12746                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12747                 {
12748                         uint32_t _flags_save_string = ndr->flags;
12749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12750                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12751                         if (_ptr_manufacturer_name) {
12752                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12753                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12754                         } else {
12755                                 r->manufacturer_name = NULL;
12756                         }
12757                         ndr->flags = _flags_save_string;
12758                 }
12759                 {
12760                         uint32_t _flags_save_string = ndr->flags;
12761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12762                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12763                         if (_ptr_manufacturer_url) {
12764                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12765                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12766                         } else {
12767                                 r->manufacturer_url = NULL;
12768                         }
12769                         ndr->flags = _flags_save_string;
12770                 }
12771                 {
12772                         uint32_t _flags_save_string = ndr->flags;
12773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12774                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12775                         if (_ptr_hardware_id) {
12776                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12777                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12778                         } else {
12779                                 r->hardware_id = NULL;
12780                         }
12781                         ndr->flags = _flags_save_string;
12782                 }
12783                 {
12784                         uint32_t _flags_save_string = ndr->flags;
12785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12786                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12787                         if (_ptr_provider) {
12788                                 NDR_PULL_ALLOC(ndr, r->provider);
12789                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12790                         } else {
12791                                 r->provider = NULL;
12792                         }
12793                         ndr->flags = _flags_save_string;
12794                 }
12795                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12796         }
12797         if (ndr_flags & NDR_BUFFERS) {
12798                 {
12799                         uint32_t _flags_save_string = ndr->flags;
12800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12801                         if (r->driver_name) {
12802                                 uint32_t _relative_save_offset;
12803                                 _relative_save_offset = ndr->offset;
12804                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12805                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12806                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12807                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12808                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12809                                 if (ndr->offset > ndr->relative_highest_offset) {
12810                                         ndr->relative_highest_offset = ndr->offset;
12811                                 }
12812                                 ndr->offset = _relative_save_offset;
12813                         }
12814                         ndr->flags = _flags_save_string;
12815                 }
12816                 {
12817                         uint32_t _flags_save_string = ndr->flags;
12818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12819                         if (r->architecture) {
12820                                 uint32_t _relative_save_offset;
12821                                 _relative_save_offset = ndr->offset;
12822                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12823                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12824                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12825                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12827                                 if (ndr->offset > ndr->relative_highest_offset) {
12828                                         ndr->relative_highest_offset = ndr->offset;
12829                                 }
12830                                 ndr->offset = _relative_save_offset;
12831                         }
12832                         ndr->flags = _flags_save_string;
12833                 }
12834                 {
12835                         uint32_t _flags_save_string = ndr->flags;
12836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12837                         if (r->driver_path) {
12838                                 uint32_t _relative_save_offset;
12839                                 _relative_save_offset = ndr->offset;
12840                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12841                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12842                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12843                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12844                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12845                                 if (ndr->offset > ndr->relative_highest_offset) {
12846                                         ndr->relative_highest_offset = ndr->offset;
12847                                 }
12848                                 ndr->offset = _relative_save_offset;
12849                         }
12850                         ndr->flags = _flags_save_string;
12851                 }
12852                 {
12853                         uint32_t _flags_save_string = ndr->flags;
12854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12855                         if (r->data_file) {
12856                                 uint32_t _relative_save_offset;
12857                                 _relative_save_offset = ndr->offset;
12858                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12859                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12860                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12861                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12862                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12863                                 if (ndr->offset > ndr->relative_highest_offset) {
12864                                         ndr->relative_highest_offset = ndr->offset;
12865                                 }
12866                                 ndr->offset = _relative_save_offset;
12867                         }
12868                         ndr->flags = _flags_save_string;
12869                 }
12870                 {
12871                         uint32_t _flags_save_string = ndr->flags;
12872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12873                         if (r->config_file) {
12874                                 uint32_t _relative_save_offset;
12875                                 _relative_save_offset = ndr->offset;
12876                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12877                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12878                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12879                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12880                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12881                                 if (ndr->offset > ndr->relative_highest_offset) {
12882                                         ndr->relative_highest_offset = ndr->offset;
12883                                 }
12884                                 ndr->offset = _relative_save_offset;
12885                         }
12886                         ndr->flags = _flags_save_string;
12887                 }
12888                 {
12889                         uint32_t _flags_save_string = ndr->flags;
12890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12891                         if (r->help_file) {
12892                                 uint32_t _relative_save_offset;
12893                                 _relative_save_offset = ndr->offset;
12894                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12895                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12896                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12897                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12898                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12899                                 if (ndr->offset > ndr->relative_highest_offset) {
12900                                         ndr->relative_highest_offset = ndr->offset;
12901                                 }
12902                                 ndr->offset = _relative_save_offset;
12903                         }
12904                         ndr->flags = _flags_save_string;
12905                 }
12906                 {
12907                         uint32_t _flags_save_string_array = ndr->flags;
12908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12909                         if (r->dependent_files) {
12910                                 uint32_t _relative_save_offset;
12911                                 _relative_save_offset = ndr->offset;
12912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12913                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12914                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12915                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12917                                 if (ndr->offset > ndr->relative_highest_offset) {
12918                                         ndr->relative_highest_offset = ndr->offset;
12919                                 }
12920                                 ndr->offset = _relative_save_offset;
12921                         }
12922                         ndr->flags = _flags_save_string_array;
12923                 }
12924                 {
12925                         uint32_t _flags_save_string = ndr->flags;
12926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12927                         if (r->monitor_name) {
12928                                 uint32_t _relative_save_offset;
12929                                 _relative_save_offset = ndr->offset;
12930                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12931                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12932                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12933                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12934                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12935                                 if (ndr->offset > ndr->relative_highest_offset) {
12936                                         ndr->relative_highest_offset = ndr->offset;
12937                                 }
12938                                 ndr->offset = _relative_save_offset;
12939                         }
12940                         ndr->flags = _flags_save_string;
12941                 }
12942                 {
12943                         uint32_t _flags_save_string = ndr->flags;
12944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12945                         if (r->default_datatype) {
12946                                 uint32_t _relative_save_offset;
12947                                 _relative_save_offset = ndr->offset;
12948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12949                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12950                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12953                                 if (ndr->offset > ndr->relative_highest_offset) {
12954                                         ndr->relative_highest_offset = ndr->offset;
12955                                 }
12956                                 ndr->offset = _relative_save_offset;
12957                         }
12958                         ndr->flags = _flags_save_string;
12959                 }
12960                 {
12961                         uint32_t _flags_save_string_array = ndr->flags;
12962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12963                         if (r->previous_names) {
12964                                 uint32_t _relative_save_offset;
12965                                 _relative_save_offset = ndr->offset;
12966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12967                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12968                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12969                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12971                                 if (ndr->offset > ndr->relative_highest_offset) {
12972                                         ndr->relative_highest_offset = ndr->offset;
12973                                 }
12974                                 ndr->offset = _relative_save_offset;
12975                         }
12976                         ndr->flags = _flags_save_string_array;
12977                 }
12978                 {
12979                         uint32_t _flags_save_string = ndr->flags;
12980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12981                         if (r->manufacturer_name) {
12982                                 uint32_t _relative_save_offset;
12983                                 _relative_save_offset = ndr->offset;
12984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12985                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12986                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12989                                 if (ndr->offset > ndr->relative_highest_offset) {
12990                                         ndr->relative_highest_offset = ndr->offset;
12991                                 }
12992                                 ndr->offset = _relative_save_offset;
12993                         }
12994                         ndr->flags = _flags_save_string;
12995                 }
12996                 {
12997                         uint32_t _flags_save_string = ndr->flags;
12998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12999                         if (r->manufacturer_url) {
13000                                 uint32_t _relative_save_offset;
13001                                 _relative_save_offset = ndr->offset;
13002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13003                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13004                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13007                                 if (ndr->offset > ndr->relative_highest_offset) {
13008                                         ndr->relative_highest_offset = ndr->offset;
13009                                 }
13010                                 ndr->offset = _relative_save_offset;
13011                         }
13012                         ndr->flags = _flags_save_string;
13013                 }
13014                 {
13015                         uint32_t _flags_save_string = ndr->flags;
13016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13017                         if (r->hardware_id) {
13018                                 uint32_t _relative_save_offset;
13019                                 _relative_save_offset = ndr->offset;
13020                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13021                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13022                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13023                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13024                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13025                                 if (ndr->offset > ndr->relative_highest_offset) {
13026                                         ndr->relative_highest_offset = ndr->offset;
13027                                 }
13028                                 ndr->offset = _relative_save_offset;
13029                         }
13030                         ndr->flags = _flags_save_string;
13031                 }
13032                 {
13033                         uint32_t _flags_save_string = ndr->flags;
13034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13035                         if (r->provider) {
13036                                 uint32_t _relative_save_offset;
13037                                 _relative_save_offset = ndr->offset;
13038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13039                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13040                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13043                                 if (ndr->offset > ndr->relative_highest_offset) {
13044                                         ndr->relative_highest_offset = ndr->offset;
13045                                 }
13046                                 ndr->offset = _relative_save_offset;
13047                         }
13048                         ndr->flags = _flags_save_string;
13049                 }
13050         }
13051         return NDR_ERR_SUCCESS;
13052 }
13053
13054 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13055 {
13056         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13057         ndr->depth++;
13058         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13059         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13060         ndr->depth++;
13061         if (r->driver_name) {
13062                 ndr_print_string(ndr, "driver_name", r->driver_name);
13063         }
13064         ndr->depth--;
13065         ndr_print_ptr(ndr, "architecture", r->architecture);
13066         ndr->depth++;
13067         if (r->architecture) {
13068                 ndr_print_string(ndr, "architecture", r->architecture);
13069         }
13070         ndr->depth--;
13071         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13072         ndr->depth++;
13073         if (r->driver_path) {
13074                 ndr_print_string(ndr, "driver_path", r->driver_path);
13075         }
13076         ndr->depth--;
13077         ndr_print_ptr(ndr, "data_file", r->data_file);
13078         ndr->depth++;
13079         if (r->data_file) {
13080                 ndr_print_string(ndr, "data_file", r->data_file);
13081         }
13082         ndr->depth--;
13083         ndr_print_ptr(ndr, "config_file", r->config_file);
13084         ndr->depth++;
13085         if (r->config_file) {
13086                 ndr_print_string(ndr, "config_file", r->config_file);
13087         }
13088         ndr->depth--;
13089         ndr_print_ptr(ndr, "help_file", r->help_file);
13090         ndr->depth++;
13091         if (r->help_file) {
13092                 ndr_print_string(ndr, "help_file", r->help_file);
13093         }
13094         ndr->depth--;
13095         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13096         ndr->depth++;
13097         if (r->dependent_files) {
13098                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13099         }
13100         ndr->depth--;
13101         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13102         ndr->depth++;
13103         if (r->monitor_name) {
13104                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13105         }
13106         ndr->depth--;
13107         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13108         ndr->depth++;
13109         if (r->default_datatype) {
13110                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13111         }
13112         ndr->depth--;
13113         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13114         ndr->depth++;
13115         if (r->previous_names) {
13116                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13117         }
13118         ndr->depth--;
13119         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13120         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13121         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13122         ndr->depth++;
13123         if (r->manufacturer_name) {
13124                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13125         }
13126         ndr->depth--;
13127         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13128         ndr->depth++;
13129         if (r->manufacturer_url) {
13130                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13131         }
13132         ndr->depth--;
13133         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13134         ndr->depth++;
13135         if (r->hardware_id) {
13136                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13137         }
13138         ndr->depth--;
13139         ndr_print_ptr(ndr, "provider", r->provider);
13140         ndr->depth++;
13141         if (r->provider) {
13142                 ndr_print_string(ndr, "provider", r->provider);
13143         }
13144         ndr->depth--;
13145         ndr->depth--;
13146 }
13147
13148 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13149 {
13150         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13151 }
13152
13153 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13154 {
13155         if (ndr_flags & NDR_SCALARS) {
13156                 NDR_CHECK(ndr_push_align(ndr, 8));
13157                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13158                 {
13159                         uint32_t _flags_save_string = ndr->flags;
13160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13161                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13162                         ndr->flags = _flags_save_string;
13163                 }
13164                 {
13165                         uint32_t _flags_save_string = ndr->flags;
13166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13167                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13168                         ndr->flags = _flags_save_string;
13169                 }
13170                 {
13171                         uint32_t _flags_save_string = ndr->flags;
13172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13173                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13174                         ndr->flags = _flags_save_string;
13175                 }
13176                 {
13177                         uint32_t _flags_save_string = ndr->flags;
13178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13179                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13180                         ndr->flags = _flags_save_string;
13181                 }
13182                 {
13183                         uint32_t _flags_save_string = ndr->flags;
13184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13185                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13186                         ndr->flags = _flags_save_string;
13187                 }
13188                 {
13189                         uint32_t _flags_save_string = ndr->flags;
13190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13191                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13192                         ndr->flags = _flags_save_string;
13193                 }
13194                 {
13195                         uint32_t _flags_save_string = ndr->flags;
13196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13198                         ndr->flags = _flags_save_string;
13199                 }
13200                 {
13201                         uint32_t _flags_save_string = ndr->flags;
13202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13204                         ndr->flags = _flags_save_string;
13205                 }
13206                 {
13207                         uint32_t _flags_save_string_array = ndr->flags;
13208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13210                         ndr->flags = _flags_save_string_array;
13211                 }
13212                 {
13213                         uint32_t _flags_save_string_array = ndr->flags;
13214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13216                         ndr->flags = _flags_save_string_array;
13217                 }
13218                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13219                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13220                 {
13221                         uint32_t _flags_save_string = ndr->flags;
13222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13224                         ndr->flags = _flags_save_string;
13225                 }
13226                 {
13227                         uint32_t _flags_save_string = ndr->flags;
13228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13230                         ndr->flags = _flags_save_string;
13231                 }
13232                 {
13233                         uint32_t _flags_save_string = ndr->flags;
13234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13235                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13236                         ndr->flags = _flags_save_string;
13237                 }
13238                 {
13239                         uint32_t _flags_save_string = ndr->flags;
13240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13242                         ndr->flags = _flags_save_string;
13243                 }
13244                 {
13245                         uint32_t _flags_save_string = ndr->flags;
13246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13247                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13248                         ndr->flags = _flags_save_string;
13249                 }
13250                 {
13251                         uint32_t _flags_save_string = ndr->flags;
13252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13254                         ndr->flags = _flags_save_string;
13255                 }
13256                 {
13257                         uint32_t _flags_save_string_array = ndr->flags;
13258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13260                         ndr->flags = _flags_save_string_array;
13261                 }
13262                 {
13263                         uint32_t _flags_save_string = ndr->flags;
13264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13266                         ndr->flags = _flags_save_string;
13267                 }
13268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13269                 {
13270                         uint32_t _flags_save_string_array = ndr->flags;
13271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13272                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13273                         ndr->flags = _flags_save_string_array;
13274                 }
13275                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13276                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13277                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13278         }
13279         if (ndr_flags & NDR_BUFFERS) {
13280                 {
13281                         uint32_t _flags_save_string = ndr->flags;
13282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13283                         if (r->driver_name) {
13284                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
13285                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
13293                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
13294                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
13302                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
13303                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
13311                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
13312                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
13320                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
13321                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_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->help_file) {
13329                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
13330                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
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->monitor_name) {
13338                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13339                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13340                         }
13341                         ndr->flags = _flags_save_string;
13342                 }
13343                 {
13344                         uint32_t _flags_save_string = ndr->flags;
13345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13346                         if (r->default_datatype) {
13347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
13348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13349                         }
13350                         ndr->flags = _flags_save_string;
13351                 }
13352                 {
13353                         uint32_t _flags_save_string_array = ndr->flags;
13354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13355                         if (r->dependent_files) {
13356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
13357                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13358                         }
13359                         ndr->flags = _flags_save_string_array;
13360                 }
13361                 {
13362                         uint32_t _flags_save_string_array = ndr->flags;
13363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13364                         if (r->previous_names) {
13365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
13366                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13367                         }
13368                         ndr->flags = _flags_save_string_array;
13369                 }
13370                 {
13371                         uint32_t _flags_save_string = ndr->flags;
13372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13373                         if (r->manufacturer_name) {
13374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
13375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
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->manufacturer_url) {
13383                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
13384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
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->hardware_id) {
13392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
13393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
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->provider) {
13401                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
13402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
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->print_processor) {
13410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13412                         }
13413                         ndr->flags = _flags_save_string;
13414                 }
13415                 {
13416                         uint32_t _flags_save_string = ndr->flags;
13417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13418                         if (r->vendor_setup) {
13419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13421                         }
13422                         ndr->flags = _flags_save_string;
13423                 }
13424                 {
13425                         uint32_t _flags_save_string_array = ndr->flags;
13426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13427                         if (r->color_profiles) {
13428                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13429                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13430                         }
13431                         ndr->flags = _flags_save_string_array;
13432                 }
13433                 {
13434                         uint32_t _flags_save_string = ndr->flags;
13435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13436                         if (r->inf_path) {
13437                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13438                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13439                         }
13440                         ndr->flags = _flags_save_string;
13441                 }
13442                 {
13443                         uint32_t _flags_save_string_array = ndr->flags;
13444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13445                         if (r->core_driver_dependencies) {
13446                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13447                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13448                         }
13449                         ndr->flags = _flags_save_string_array;
13450                 }
13451         }
13452         return NDR_ERR_SUCCESS;
13453 }
13454
13455 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13456 {
13457         uint32_t _ptr_driver_name;
13458         TALLOC_CTX *_mem_save_driver_name_0;
13459         uint32_t _ptr_architecture;
13460         TALLOC_CTX *_mem_save_architecture_0;
13461         uint32_t _ptr_driver_path;
13462         TALLOC_CTX *_mem_save_driver_path_0;
13463         uint32_t _ptr_data_file;
13464         TALLOC_CTX *_mem_save_data_file_0;
13465         uint32_t _ptr_config_file;
13466         TALLOC_CTX *_mem_save_config_file_0;
13467         uint32_t _ptr_help_file;
13468         TALLOC_CTX *_mem_save_help_file_0;
13469         uint32_t _ptr_monitor_name;
13470         TALLOC_CTX *_mem_save_monitor_name_0;
13471         uint32_t _ptr_default_datatype;
13472         TALLOC_CTX *_mem_save_default_datatype_0;
13473         uint32_t _ptr_dependent_files;
13474         TALLOC_CTX *_mem_save_dependent_files_0;
13475         uint32_t _ptr_previous_names;
13476         TALLOC_CTX *_mem_save_previous_names_0;
13477         uint32_t _ptr_manufacturer_name;
13478         TALLOC_CTX *_mem_save_manufacturer_name_0;
13479         uint32_t _ptr_manufacturer_url;
13480         TALLOC_CTX *_mem_save_manufacturer_url_0;
13481         uint32_t _ptr_hardware_id;
13482         TALLOC_CTX *_mem_save_hardware_id_0;
13483         uint32_t _ptr_provider;
13484         TALLOC_CTX *_mem_save_provider_0;
13485         uint32_t _ptr_print_processor;
13486         TALLOC_CTX *_mem_save_print_processor_0;
13487         uint32_t _ptr_vendor_setup;
13488         TALLOC_CTX *_mem_save_vendor_setup_0;
13489         uint32_t _ptr_color_profiles;
13490         TALLOC_CTX *_mem_save_color_profiles_0;
13491         uint32_t _ptr_inf_path;
13492         TALLOC_CTX *_mem_save_inf_path_0;
13493         uint32_t _ptr_core_driver_dependencies;
13494         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13495         if (ndr_flags & NDR_SCALARS) {
13496                 NDR_CHECK(ndr_pull_align(ndr, 8));
13497                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13498                 {
13499                         uint32_t _flags_save_string = ndr->flags;
13500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13501                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13502                         if (_ptr_driver_name) {
13503                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13504                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13505                         } else {
13506                                 r->driver_name = NULL;
13507                         }
13508                         ndr->flags = _flags_save_string;
13509                 }
13510                 {
13511                         uint32_t _flags_save_string = ndr->flags;
13512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13514                         if (_ptr_architecture) {
13515                                 NDR_PULL_ALLOC(ndr, r->architecture);
13516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13517                         } else {
13518                                 r->architecture = NULL;
13519                         }
13520                         ndr->flags = _flags_save_string;
13521                 }
13522                 {
13523                         uint32_t _flags_save_string = ndr->flags;
13524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13525                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13526                         if (_ptr_driver_path) {
13527                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13528                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13529                         } else {
13530                                 r->driver_path = NULL;
13531                         }
13532                         ndr->flags = _flags_save_string;
13533                 }
13534                 {
13535                         uint32_t _flags_save_string = ndr->flags;
13536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13538                         if (_ptr_data_file) {
13539                                 NDR_PULL_ALLOC(ndr, r->data_file);
13540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13541                         } else {
13542                                 r->data_file = NULL;
13543                         }
13544                         ndr->flags = _flags_save_string;
13545                 }
13546                 {
13547                         uint32_t _flags_save_string = ndr->flags;
13548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13550                         if (_ptr_config_file) {
13551                                 NDR_PULL_ALLOC(ndr, r->config_file);
13552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13553                         } else {
13554                                 r->config_file = NULL;
13555                         }
13556                         ndr->flags = _flags_save_string;
13557                 }
13558                 {
13559                         uint32_t _flags_save_string = ndr->flags;
13560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13562                         if (_ptr_help_file) {
13563                                 NDR_PULL_ALLOC(ndr, r->help_file);
13564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13565                         } else {
13566                                 r->help_file = NULL;
13567                         }
13568                         ndr->flags = _flags_save_string;
13569                 }
13570                 {
13571                         uint32_t _flags_save_string = ndr->flags;
13572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13573                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13574                         if (_ptr_monitor_name) {
13575                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13576                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13577                         } else {
13578                                 r->monitor_name = NULL;
13579                         }
13580                         ndr->flags = _flags_save_string;
13581                 }
13582                 {
13583                         uint32_t _flags_save_string = ndr->flags;
13584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13585                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13586                         if (_ptr_default_datatype) {
13587                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13588                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13589                         } else {
13590                                 r->default_datatype = NULL;
13591                         }
13592                         ndr->flags = _flags_save_string;
13593                 }
13594                 {
13595                         uint32_t _flags_save_string_array = ndr->flags;
13596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13597                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13598                         if (_ptr_dependent_files) {
13599                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13600                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13601                         } else {
13602                                 r->dependent_files = NULL;
13603                         }
13604                         ndr->flags = _flags_save_string_array;
13605                 }
13606                 {
13607                         uint32_t _flags_save_string_array = ndr->flags;
13608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13609                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13610                         if (_ptr_previous_names) {
13611                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13612                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13613                         } else {
13614                                 r->previous_names = NULL;
13615                         }
13616                         ndr->flags = _flags_save_string_array;
13617                 }
13618                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13619                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13620                 {
13621                         uint32_t _flags_save_string = ndr->flags;
13622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13623                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13624                         if (_ptr_manufacturer_name) {
13625                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13626                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13627                         } else {
13628                                 r->manufacturer_name = NULL;
13629                         }
13630                         ndr->flags = _flags_save_string;
13631                 }
13632                 {
13633                         uint32_t _flags_save_string = ndr->flags;
13634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13635                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13636                         if (_ptr_manufacturer_url) {
13637                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13638                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13639                         } else {
13640                                 r->manufacturer_url = NULL;
13641                         }
13642                         ndr->flags = _flags_save_string;
13643                 }
13644                 {
13645                         uint32_t _flags_save_string = ndr->flags;
13646                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13647                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13648                         if (_ptr_hardware_id) {
13649                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13650                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13651                         } else {
13652                                 r->hardware_id = NULL;
13653                         }
13654                         ndr->flags = _flags_save_string;
13655                 }
13656                 {
13657                         uint32_t _flags_save_string = ndr->flags;
13658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13659                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13660                         if (_ptr_provider) {
13661                                 NDR_PULL_ALLOC(ndr, r->provider);
13662                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13663                         } else {
13664                                 r->provider = NULL;
13665                         }
13666                         ndr->flags = _flags_save_string;
13667                 }
13668                 {
13669                         uint32_t _flags_save_string = ndr->flags;
13670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13671                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13672                         if (_ptr_print_processor) {
13673                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13674                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13675                         } else {
13676                                 r->print_processor = NULL;
13677                         }
13678                         ndr->flags = _flags_save_string;
13679                 }
13680                 {
13681                         uint32_t _flags_save_string = ndr->flags;
13682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13683                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13684                         if (_ptr_vendor_setup) {
13685                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13686                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13687                         } else {
13688                                 r->vendor_setup = NULL;
13689                         }
13690                         ndr->flags = _flags_save_string;
13691                 }
13692                 {
13693                         uint32_t _flags_save_string_array = ndr->flags;
13694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13695                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13696                         if (_ptr_color_profiles) {
13697                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13698                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13699                         } else {
13700                                 r->color_profiles = NULL;
13701                         }
13702                         ndr->flags = _flags_save_string_array;
13703                 }
13704                 {
13705                         uint32_t _flags_save_string = ndr->flags;
13706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13708                         if (_ptr_inf_path) {
13709                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13711                         } else {
13712                                 r->inf_path = NULL;
13713                         }
13714                         ndr->flags = _flags_save_string;
13715                 }
13716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13717                 {
13718                         uint32_t _flags_save_string_array = ndr->flags;
13719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13721                         if (_ptr_core_driver_dependencies) {
13722                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13724                         } else {
13725                                 r->core_driver_dependencies = NULL;
13726                         }
13727                         ndr->flags = _flags_save_string_array;
13728                 }
13729                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13730                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13731                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13732         }
13733         if (ndr_flags & NDR_BUFFERS) {
13734                 {
13735                         uint32_t _flags_save_string = ndr->flags;
13736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13737                         if (r->driver_name) {
13738                                 uint32_t _relative_save_offset;
13739                                 _relative_save_offset = ndr->offset;
13740                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13741                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13742                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13743                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13744                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13745                                 if (ndr->offset > ndr->relative_highest_offset) {
13746                                         ndr->relative_highest_offset = ndr->offset;
13747                                 }
13748                                 ndr->offset = _relative_save_offset;
13749                         }
13750                         ndr->flags = _flags_save_string;
13751                 }
13752                 {
13753                         uint32_t _flags_save_string = ndr->flags;
13754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13755                         if (r->architecture) {
13756                                 uint32_t _relative_save_offset;
13757                                 _relative_save_offset = ndr->offset;
13758                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13759                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13760                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13761                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13762                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13763                                 if (ndr->offset > ndr->relative_highest_offset) {
13764                                         ndr->relative_highest_offset = ndr->offset;
13765                                 }
13766                                 ndr->offset = _relative_save_offset;
13767                         }
13768                         ndr->flags = _flags_save_string;
13769                 }
13770                 {
13771                         uint32_t _flags_save_string = ndr->flags;
13772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13773                         if (r->driver_path) {
13774                                 uint32_t _relative_save_offset;
13775                                 _relative_save_offset = ndr->offset;
13776                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13777                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13778                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13779                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13780                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13781                                 if (ndr->offset > ndr->relative_highest_offset) {
13782                                         ndr->relative_highest_offset = ndr->offset;
13783                                 }
13784                                 ndr->offset = _relative_save_offset;
13785                         }
13786                         ndr->flags = _flags_save_string;
13787                 }
13788                 {
13789                         uint32_t _flags_save_string = ndr->flags;
13790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13791                         if (r->data_file) {
13792                                 uint32_t _relative_save_offset;
13793                                 _relative_save_offset = ndr->offset;
13794                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13795                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13796                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13797                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13798                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13799                                 if (ndr->offset > ndr->relative_highest_offset) {
13800                                         ndr->relative_highest_offset = ndr->offset;
13801                                 }
13802                                 ndr->offset = _relative_save_offset;
13803                         }
13804                         ndr->flags = _flags_save_string;
13805                 }
13806                 {
13807                         uint32_t _flags_save_string = ndr->flags;
13808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13809                         if (r->config_file) {
13810                                 uint32_t _relative_save_offset;
13811                                 _relative_save_offset = ndr->offset;
13812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13813                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13814                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13817                                 if (ndr->offset > ndr->relative_highest_offset) {
13818                                         ndr->relative_highest_offset = ndr->offset;
13819                                 }
13820                                 ndr->offset = _relative_save_offset;
13821                         }
13822                         ndr->flags = _flags_save_string;
13823                 }
13824                 {
13825                         uint32_t _flags_save_string = ndr->flags;
13826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13827                         if (r->help_file) {
13828                                 uint32_t _relative_save_offset;
13829                                 _relative_save_offset = ndr->offset;
13830                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13831                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13832                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13833                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13834                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13835                                 if (ndr->offset > ndr->relative_highest_offset) {
13836                                         ndr->relative_highest_offset = ndr->offset;
13837                                 }
13838                                 ndr->offset = _relative_save_offset;
13839                         }
13840                         ndr->flags = _flags_save_string;
13841                 }
13842                 {
13843                         uint32_t _flags_save_string = ndr->flags;
13844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13845                         if (r->monitor_name) {
13846                                 uint32_t _relative_save_offset;
13847                                 _relative_save_offset = ndr->offset;
13848                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13849                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13850                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13851                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13852                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13853                                 if (ndr->offset > ndr->relative_highest_offset) {
13854                                         ndr->relative_highest_offset = ndr->offset;
13855                                 }
13856                                 ndr->offset = _relative_save_offset;
13857                         }
13858                         ndr->flags = _flags_save_string;
13859                 }
13860                 {
13861                         uint32_t _flags_save_string = ndr->flags;
13862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13863                         if (r->default_datatype) {
13864                                 uint32_t _relative_save_offset;
13865                                 _relative_save_offset = ndr->offset;
13866                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13867                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13868                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13869                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13870                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13871                                 if (ndr->offset > ndr->relative_highest_offset) {
13872                                         ndr->relative_highest_offset = ndr->offset;
13873                                 }
13874                                 ndr->offset = _relative_save_offset;
13875                         }
13876                         ndr->flags = _flags_save_string;
13877                 }
13878                 {
13879                         uint32_t _flags_save_string_array = ndr->flags;
13880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13881                         if (r->dependent_files) {
13882                                 uint32_t _relative_save_offset;
13883                                 _relative_save_offset = ndr->offset;
13884                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13885                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13886                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13887                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13888                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13889                                 if (ndr->offset > ndr->relative_highest_offset) {
13890                                         ndr->relative_highest_offset = ndr->offset;
13891                                 }
13892                                 ndr->offset = _relative_save_offset;
13893                         }
13894                         ndr->flags = _flags_save_string_array;
13895                 }
13896                 {
13897                         uint32_t _flags_save_string_array = ndr->flags;
13898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13899                         if (r->previous_names) {
13900                                 uint32_t _relative_save_offset;
13901                                 _relative_save_offset = ndr->offset;
13902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13903                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13904                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13905                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13907                                 if (ndr->offset > ndr->relative_highest_offset) {
13908                                         ndr->relative_highest_offset = ndr->offset;
13909                                 }
13910                                 ndr->offset = _relative_save_offset;
13911                         }
13912                         ndr->flags = _flags_save_string_array;
13913                 }
13914                 {
13915                         uint32_t _flags_save_string = ndr->flags;
13916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13917                         if (r->manufacturer_name) {
13918                                 uint32_t _relative_save_offset;
13919                                 _relative_save_offset = ndr->offset;
13920                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13921                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13922                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13923                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13924                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13925                                 if (ndr->offset > ndr->relative_highest_offset) {
13926                                         ndr->relative_highest_offset = ndr->offset;
13927                                 }
13928                                 ndr->offset = _relative_save_offset;
13929                         }
13930                         ndr->flags = _flags_save_string;
13931                 }
13932                 {
13933                         uint32_t _flags_save_string = ndr->flags;
13934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13935                         if (r->manufacturer_url) {
13936                                 uint32_t _relative_save_offset;
13937                                 _relative_save_offset = ndr->offset;
13938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13939                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13940                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13943                                 if (ndr->offset > ndr->relative_highest_offset) {
13944                                         ndr->relative_highest_offset = ndr->offset;
13945                                 }
13946                                 ndr->offset = _relative_save_offset;
13947                         }
13948                         ndr->flags = _flags_save_string;
13949                 }
13950                 {
13951                         uint32_t _flags_save_string = ndr->flags;
13952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13953                         if (r->hardware_id) {
13954                                 uint32_t _relative_save_offset;
13955                                 _relative_save_offset = ndr->offset;
13956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13957                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13958                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13961                                 if (ndr->offset > ndr->relative_highest_offset) {
13962                                         ndr->relative_highest_offset = ndr->offset;
13963                                 }
13964                                 ndr->offset = _relative_save_offset;
13965                         }
13966                         ndr->flags = _flags_save_string;
13967                 }
13968                 {
13969                         uint32_t _flags_save_string = ndr->flags;
13970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13971                         if (r->provider) {
13972                                 uint32_t _relative_save_offset;
13973                                 _relative_save_offset = ndr->offset;
13974                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13975                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13976                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13977                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13978                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13979                                 if (ndr->offset > ndr->relative_highest_offset) {
13980                                         ndr->relative_highest_offset = ndr->offset;
13981                                 }
13982                                 ndr->offset = _relative_save_offset;
13983                         }
13984                         ndr->flags = _flags_save_string;
13985                 }
13986                 {
13987                         uint32_t _flags_save_string = ndr->flags;
13988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13989                         if (r->print_processor) {
13990                                 uint32_t _relative_save_offset;
13991                                 _relative_save_offset = ndr->offset;
13992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13993                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13994                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13995                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13997                                 if (ndr->offset > ndr->relative_highest_offset) {
13998                                         ndr->relative_highest_offset = ndr->offset;
13999                                 }
14000                                 ndr->offset = _relative_save_offset;
14001                         }
14002                         ndr->flags = _flags_save_string;
14003                 }
14004                 {
14005                         uint32_t _flags_save_string = ndr->flags;
14006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14007                         if (r->vendor_setup) {
14008                                 uint32_t _relative_save_offset;
14009                                 _relative_save_offset = ndr->offset;
14010                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14011                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14012                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14013                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14014                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14015                                 if (ndr->offset > ndr->relative_highest_offset) {
14016                                         ndr->relative_highest_offset = ndr->offset;
14017                                 }
14018                                 ndr->offset = _relative_save_offset;
14019                         }
14020                         ndr->flags = _flags_save_string;
14021                 }
14022                 {
14023                         uint32_t _flags_save_string_array = ndr->flags;
14024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14025                         if (r->color_profiles) {
14026                                 uint32_t _relative_save_offset;
14027                                 _relative_save_offset = ndr->offset;
14028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14029                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14030                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14031                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14033                                 if (ndr->offset > ndr->relative_highest_offset) {
14034                                         ndr->relative_highest_offset = ndr->offset;
14035                                 }
14036                                 ndr->offset = _relative_save_offset;
14037                         }
14038                         ndr->flags = _flags_save_string_array;
14039                 }
14040                 {
14041                         uint32_t _flags_save_string = ndr->flags;
14042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14043                         if (r->inf_path) {
14044                                 uint32_t _relative_save_offset;
14045                                 _relative_save_offset = ndr->offset;
14046                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14047                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14048                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14049                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14050                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14051                                 if (ndr->offset > ndr->relative_highest_offset) {
14052                                         ndr->relative_highest_offset = ndr->offset;
14053                                 }
14054                                 ndr->offset = _relative_save_offset;
14055                         }
14056                         ndr->flags = _flags_save_string;
14057                 }
14058                 {
14059                         uint32_t _flags_save_string_array = ndr->flags;
14060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14061                         if (r->core_driver_dependencies) {
14062                                 uint32_t _relative_save_offset;
14063                                 _relative_save_offset = ndr->offset;
14064                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14065                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14066                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14067                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14069                                 if (ndr->offset > ndr->relative_highest_offset) {
14070                                         ndr->relative_highest_offset = ndr->offset;
14071                                 }
14072                                 ndr->offset = _relative_save_offset;
14073                         }
14074                         ndr->flags = _flags_save_string_array;
14075                 }
14076         }
14077         return NDR_ERR_SUCCESS;
14078 }
14079
14080 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14081 {
14082         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14083         ndr->depth++;
14084         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14085         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14086         ndr->depth++;
14087         if (r->driver_name) {
14088                 ndr_print_string(ndr, "driver_name", r->driver_name);
14089         }
14090         ndr->depth--;
14091         ndr_print_ptr(ndr, "architecture", r->architecture);
14092         ndr->depth++;
14093         if (r->architecture) {
14094                 ndr_print_string(ndr, "architecture", r->architecture);
14095         }
14096         ndr->depth--;
14097         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14098         ndr->depth++;
14099         if (r->driver_path) {
14100                 ndr_print_string(ndr, "driver_path", r->driver_path);
14101         }
14102         ndr->depth--;
14103         ndr_print_ptr(ndr, "data_file", r->data_file);
14104         ndr->depth++;
14105         if (r->data_file) {
14106                 ndr_print_string(ndr, "data_file", r->data_file);
14107         }
14108         ndr->depth--;
14109         ndr_print_ptr(ndr, "config_file", r->config_file);
14110         ndr->depth++;
14111         if (r->config_file) {
14112                 ndr_print_string(ndr, "config_file", r->config_file);
14113         }
14114         ndr->depth--;
14115         ndr_print_ptr(ndr, "help_file", r->help_file);
14116         ndr->depth++;
14117         if (r->help_file) {
14118                 ndr_print_string(ndr, "help_file", r->help_file);
14119         }
14120         ndr->depth--;
14121         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14122         ndr->depth++;
14123         if (r->monitor_name) {
14124                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14125         }
14126         ndr->depth--;
14127         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14128         ndr->depth++;
14129         if (r->default_datatype) {
14130                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14131         }
14132         ndr->depth--;
14133         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14134         ndr->depth++;
14135         if (r->dependent_files) {
14136                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14137         }
14138         ndr->depth--;
14139         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14140         ndr->depth++;
14141         if (r->previous_names) {
14142                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14143         }
14144         ndr->depth--;
14145         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14146         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14147         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14148         ndr->depth++;
14149         if (r->manufacturer_name) {
14150                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14151         }
14152         ndr->depth--;
14153         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14154         ndr->depth++;
14155         if (r->manufacturer_url) {
14156                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14157         }
14158         ndr->depth--;
14159         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14160         ndr->depth++;
14161         if (r->hardware_id) {
14162                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14163         }
14164         ndr->depth--;
14165         ndr_print_ptr(ndr, "provider", r->provider);
14166         ndr->depth++;
14167         if (r->provider) {
14168                 ndr_print_string(ndr, "provider", r->provider);
14169         }
14170         ndr->depth--;
14171         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14172         ndr->depth++;
14173         if (r->print_processor) {
14174                 ndr_print_string(ndr, "print_processor", r->print_processor);
14175         }
14176         ndr->depth--;
14177         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14178         ndr->depth++;
14179         if (r->vendor_setup) {
14180                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14181         }
14182         ndr->depth--;
14183         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14184         ndr->depth++;
14185         if (r->color_profiles) {
14186                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14187         }
14188         ndr->depth--;
14189         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14190         ndr->depth++;
14191         if (r->inf_path) {
14192                 ndr_print_string(ndr, "inf_path", r->inf_path);
14193         }
14194         ndr->depth--;
14195         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14196         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14197         ndr->depth++;
14198         if (r->core_driver_dependencies) {
14199                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14200         }
14201         ndr->depth--;
14202         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14203         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14204         ndr->depth--;
14205 }
14206
14207 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14208 {
14209         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14210 }
14211
14212 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14213 {
14214         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14215         return NDR_ERR_SUCCESS;
14216 }
14217
14218 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14219 {
14220         uint32_t v;
14221         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14222         *r = v;
14223         return NDR_ERR_SUCCESS;
14224 }
14225
14226 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14227 {
14228         const char *val = NULL;
14229
14230         switch (r) {
14231                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14232                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14233                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14234                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14235                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14236         }
14237         ndr_print_enum(ndr, name, "ENUM", val, r);
14238 }
14239
14240 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14241 {
14242         if (ndr_flags & NDR_SCALARS) {
14243                 NDR_CHECK(ndr_push_align(ndr, 5));
14244                 {
14245                         uint32_t _flags_save_string = ndr->flags;
14246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14247                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14248                         ndr->flags = _flags_save_string;
14249                 }
14250                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14252                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14253         }
14254         if (ndr_flags & NDR_BUFFERS) {
14255                 {
14256                         uint32_t _flags_save_string = ndr->flags;
14257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14258                         if (r->file_name) {
14259                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
14260                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14261                         }
14262                         ndr->flags = _flags_save_string;
14263                 }
14264         }
14265         return NDR_ERR_SUCCESS;
14266 }
14267
14268 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14269 {
14270         uint32_t _ptr_file_name;
14271         TALLOC_CTX *_mem_save_file_name_0;
14272         if (ndr_flags & NDR_SCALARS) {
14273                 NDR_CHECK(ndr_pull_align(ndr, 5));
14274                 {
14275                         uint32_t _flags_save_string = ndr->flags;
14276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14277                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14278                         if (_ptr_file_name) {
14279                                 NDR_PULL_ALLOC(ndr, r->file_name);
14280                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14281                         } else {
14282                                 r->file_name = NULL;
14283                         }
14284                         ndr->flags = _flags_save_string;
14285                 }
14286                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14288                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14289         }
14290         if (ndr_flags & NDR_BUFFERS) {
14291                 {
14292                         uint32_t _flags_save_string = ndr->flags;
14293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14294                         if (r->file_name) {
14295                                 uint32_t _relative_save_offset;
14296                                 _relative_save_offset = ndr->offset;
14297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14298                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14299                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14302                                 if (ndr->offset > ndr->relative_highest_offset) {
14303                                         ndr->relative_highest_offset = ndr->offset;
14304                                 }
14305                                 ndr->offset = _relative_save_offset;
14306                         }
14307                         ndr->flags = _flags_save_string;
14308                 }
14309         }
14310         return NDR_ERR_SUCCESS;
14311 }
14312
14313 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14314 {
14315         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14316         ndr->depth++;
14317         ndr_print_ptr(ndr, "file_name", r->file_name);
14318         ndr->depth++;
14319         if (r->file_name) {
14320                 ndr_print_string(ndr, "file_name", r->file_name);
14321         }
14322         ndr->depth--;
14323         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14324         ndr_print_uint32(ndr, "file_version", r->file_version);
14325         ndr->depth--;
14326 }
14327
14328 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14329 {
14330         uint32_t cntr_file_info_1;
14331         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14332         ndr->depth++;
14333         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14334         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14335         ndr->depth++;
14336         if (r->driver_name) {
14337                 ndr_print_string(ndr, "driver_name", r->driver_name);
14338         }
14339         ndr->depth--;
14340         ndr_print_ptr(ndr, "architecture", r->architecture);
14341         ndr->depth++;
14342         if (r->architecture) {
14343                 ndr_print_string(ndr, "architecture", r->architecture);
14344         }
14345         ndr->depth--;
14346         ndr_print_ptr(ndr, "file_info", r->file_info);
14347         ndr->depth++;
14348         if (r->file_info) {
14349                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14350                 ndr->depth++;
14351                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14352                         char *idx_1=NULL;
14353                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14354                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14355                                 free(idx_1);
14356                         }
14357                 }
14358                 ndr->depth--;
14359         }
14360         ndr->depth--;
14361         ndr_print_uint32(ndr, "file_count", r->file_count);
14362         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14363         ndr->depth++;
14364         if (r->monitor_name) {
14365                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14366         }
14367         ndr->depth--;
14368         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14369         ndr->depth++;
14370         if (r->default_datatype) {
14371                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14372         }
14373         ndr->depth--;
14374         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14375         ndr->depth++;
14376         if (r->previous_names) {
14377                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14378         }
14379         ndr->depth--;
14380         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14381         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14382         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14383         ndr->depth++;
14384         if (r->manufacturer_name) {
14385                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14386         }
14387         ndr->depth--;
14388         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14389         ndr->depth++;
14390         if (r->manufacturer_url) {
14391                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14392         }
14393         ndr->depth--;
14394         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14395         ndr->depth++;
14396         if (r->hardware_id) {
14397                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14398         }
14399         ndr->depth--;
14400         ndr_print_ptr(ndr, "provider", r->provider);
14401         ndr->depth++;
14402         if (r->provider) {
14403                 ndr_print_string(ndr, "provider", r->provider);
14404         }
14405         ndr->depth--;
14406         ndr->depth--;
14407 }
14408
14409 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14410 {
14411         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14412 }
14413
14414 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14415 {
14416         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14417         if (ndr_flags & NDR_SCALARS) {
14418                 int level = ndr_push_get_switch_value(ndr, r);
14419                 NDR_CHECK(ndr_push_union_align(ndr, 8));
14420                 switch (level) {
14421                         case 1: {
14422                                 NDR_CHECK(ndr_push_align(ndr, 5));
14423                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14424                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14425                         break; }
14426
14427                         case 2: {
14428                                 NDR_CHECK(ndr_push_align(ndr, 5));
14429                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14430                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14431                         break; }
14432
14433                         case 3: {
14434                                 NDR_CHECK(ndr_push_align(ndr, 5));
14435                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14436                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14437                         break; }
14438
14439                         case 4: {
14440                                 NDR_CHECK(ndr_push_align(ndr, 5));
14441                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14442                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14443                         break; }
14444
14445                         case 5: {
14446                                 NDR_CHECK(ndr_push_align(ndr, 5));
14447                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14448                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14449                         break; }
14450
14451                         case 6: {
14452                                 NDR_CHECK(ndr_push_align(ndr, 8));
14453                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14454                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14455                         break; }
14456
14457                         case 8: {
14458                                 NDR_CHECK(ndr_push_align(ndr, 8));
14459                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14460                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14461                         break; }
14462
14463                         case 101: {
14464                                 NDR_CHECK(ndr_push_align(ndr, 8));
14465                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14466                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14467                         break; }
14468
14469                         default: {
14470                         break; }
14471
14472                 }
14473         }
14474         if (ndr_flags & NDR_BUFFERS) {
14475                 int level = ndr_push_get_switch_value(ndr, r);
14476                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14477                 switch (level) {
14478                         case 1:
14479                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14480                         break;
14481
14482                         case 2:
14483                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14484                         break;
14485
14486                         case 3:
14487                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14488                         break;
14489
14490                         case 4:
14491                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14492                         break;
14493
14494                         case 5:
14495                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14496                         break;
14497
14498                         case 6:
14499                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14500                         break;
14501
14502                         case 8:
14503                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14504                         break;
14505
14506                         case 101:
14507                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14508                         break;
14509
14510                         default:
14511                         break;
14512
14513                 }
14514         }
14515         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14516         return NDR_ERR_SUCCESS;
14517 }
14518
14519 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14520 {
14521         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14522         int level;
14523         level = ndr_pull_get_switch_value(ndr, r);
14524         if (ndr_flags & NDR_SCALARS) {
14525                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14526                 switch (level) {
14527                         case 1: {
14528                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14529                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14530                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14531                         break; }
14532
14533                         case 2: {
14534                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14535                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14536                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14537                         break; }
14538
14539                         case 3: {
14540                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14541                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14542                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14543                         break; }
14544
14545                         case 4: {
14546                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14547                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14548                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14549                         break; }
14550
14551                         case 5: {
14552                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14553                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14554                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14555                         break; }
14556
14557                         case 6: {
14558                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14559                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14560                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14561                         break; }
14562
14563                         case 8: {
14564                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14565                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14566                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14567                         break; }
14568
14569                         case 101: {
14570                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14571                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14572                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14573                         break; }
14574
14575                         default: {
14576                         break; }
14577
14578                 }
14579         }
14580         if (ndr_flags & NDR_BUFFERS) {
14581                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14582                 switch (level) {
14583                         case 1:
14584                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14585                         break;
14586
14587                         case 2:
14588                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14589                         break;
14590
14591                         case 3:
14592                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14593                         break;
14594
14595                         case 4:
14596                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14597                         break;
14598
14599                         case 5:
14600                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14601                         break;
14602
14603                         case 6:
14604                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14605                         break;
14606
14607                         case 8:
14608                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14609                         break;
14610
14611                         case 101:
14612                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14613                         break;
14614
14615                         default:
14616                         break;
14617
14618                 }
14619         }
14620         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14621         return NDR_ERR_SUCCESS;
14622 }
14623
14624 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14625 {
14626         int level;
14627         level = ndr_print_get_switch_value(ndr, r);
14628         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14629         switch (level) {
14630                 case 1:
14631                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14632                 break;
14633
14634                 case 2:
14635                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14636                 break;
14637
14638                 case 3:
14639                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14640                 break;
14641
14642                 case 4:
14643                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14644                 break;
14645
14646                 case 5:
14647                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14648                 break;
14649
14650                 case 6:
14651                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14652                 break;
14653
14654                 case 8:
14655                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14656                 break;
14657
14658                 case 101:
14659                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14660                 break;
14661
14662                 default:
14663                 break;
14664
14665         }
14666 }
14667
14668 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14669 {
14670         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14671 }
14672
14673 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14674 {
14675         if (ndr_flags & NDR_SCALARS) {
14676                 NDR_CHECK(ndr_push_align(ndr, 4));
14677                 {
14678                         uint32_t _flags_save_string = ndr->flags;
14679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14680                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14681                         ndr->flags = _flags_save_string;
14682                 }
14683                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14684         }
14685         if (ndr_flags & NDR_BUFFERS) {
14686         }
14687         return NDR_ERR_SUCCESS;
14688 }
14689
14690 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14691 {
14692         if (ndr_flags & NDR_SCALARS) {
14693                 NDR_CHECK(ndr_pull_align(ndr, 4));
14694                 {
14695                         uint32_t _flags_save_string = ndr->flags;
14696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14697                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14698                         ndr->flags = _flags_save_string;
14699                 }
14700                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14701         }
14702         if (ndr_flags & NDR_BUFFERS) {
14703         }
14704         return NDR_ERR_SUCCESS;
14705 }
14706
14707 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14708 {
14709         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14710         ndr->depth++;
14711         ndr_print_string(ndr, "directory_name", r->directory_name);
14712         ndr->depth--;
14713 }
14714
14715 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14716 {
14717         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14718 }
14719
14720 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14721 {
14722         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14723         if (ndr_flags & NDR_SCALARS) {
14724                 int level = ndr_push_get_switch_value(ndr, r);
14725                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14726                 switch (level) {
14727                         case 1: {
14728                                 NDR_CHECK(ndr_push_align(ndr, 4));
14729                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14730                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14731                         break; }
14732
14733                         default: {
14734                                 NDR_CHECK(ndr_push_align(ndr, 4));
14735                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14736                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14737                         break; }
14738
14739                 }
14740         }
14741         if (ndr_flags & NDR_BUFFERS) {
14742                 int level = ndr_push_get_switch_value(ndr, r);
14743                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14744                 switch (level) {
14745                         case 1:
14746                         break;
14747
14748                         default:
14749                         break;
14750
14751                 }
14752         }
14753         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14754         return NDR_ERR_SUCCESS;
14755 }
14756
14757 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14758 {
14759         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14760         int level;
14761         level = ndr_pull_get_switch_value(ndr, r);
14762         if (ndr_flags & NDR_SCALARS) {
14763                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14764                 switch (level) {
14765                         case 1: {
14766                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14767                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14768                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14769                         break; }
14770
14771                         default: {
14772                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14773                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14774                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14775                         break; }
14776
14777                 }
14778         }
14779         if (ndr_flags & NDR_BUFFERS) {
14780                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14781                 switch (level) {
14782                         case 1:
14783                         break;
14784
14785                         default:
14786                         break;
14787
14788                 }
14789         }
14790         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14791         return NDR_ERR_SUCCESS;
14792 }
14793
14794 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14795 {
14796         int level;
14797         level = ndr_print_get_switch_value(ndr, r);
14798         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14799         switch (level) {
14800                 case 1:
14801                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14802                 break;
14803
14804                 default:
14805                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14806                 break;
14807
14808         }
14809 }
14810
14811 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14812 {
14813         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14814 }
14815
14816 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14817 {
14818         if (ndr_flags & NDR_SCALARS) {
14819                 NDR_CHECK(ndr_push_align(ndr, 5));
14820                 {
14821                         uint32_t _flags_save_string = ndr->flags;
14822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14823                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14824                         ndr->flags = _flags_save_string;
14825                 }
14826                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14827         }
14828         if (ndr_flags & NDR_BUFFERS) {
14829                 {
14830                         uint32_t _flags_save_string = ndr->flags;
14831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14832                         if (r->print_processor_name) {
14833                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
14834                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14835                         }
14836                         ndr->flags = _flags_save_string;
14837                 }
14838         }
14839         return NDR_ERR_SUCCESS;
14840 }
14841
14842 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14843 {
14844         uint32_t _ptr_print_processor_name;
14845         TALLOC_CTX *_mem_save_print_processor_name_0;
14846         if (ndr_flags & NDR_SCALARS) {
14847                 NDR_CHECK(ndr_pull_align(ndr, 5));
14848                 {
14849                         uint32_t _flags_save_string = ndr->flags;
14850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14851                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14852                         if (_ptr_print_processor_name) {
14853                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
14854                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14855                         } else {
14856                                 r->print_processor_name = NULL;
14857                         }
14858                         ndr->flags = _flags_save_string;
14859                 }
14860                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14861         }
14862         if (ndr_flags & NDR_BUFFERS) {
14863                 {
14864                         uint32_t _flags_save_string = ndr->flags;
14865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14866                         if (r->print_processor_name) {
14867                                 uint32_t _relative_save_offset;
14868                                 _relative_save_offset = ndr->offset;
14869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14870                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14871                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14872                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14874                                 if (ndr->offset > ndr->relative_highest_offset) {
14875                                         ndr->relative_highest_offset = ndr->offset;
14876                                 }
14877                                 ndr->offset = _relative_save_offset;
14878                         }
14879                         ndr->flags = _flags_save_string;
14880                 }
14881         }
14882         return NDR_ERR_SUCCESS;
14883 }
14884
14885 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14886 {
14887         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14888         ndr->depth++;
14889         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14890         ndr->depth++;
14891         if (r->print_processor_name) {
14892                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14893         }
14894         ndr->depth--;
14895         ndr->depth--;
14896 }
14897
14898 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14899 {
14900         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14901 }
14902
14903 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14904 {
14905         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14906         if (ndr_flags & NDR_SCALARS) {
14907                 int level = ndr_push_get_switch_value(ndr, r);
14908                 NDR_CHECK(ndr_push_union_align(ndr, 5));
14909                 switch (level) {
14910                         case 1: {
14911                                 NDR_CHECK(ndr_push_align(ndr, 5));
14912                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14913                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14914                         break; }
14915
14916                         default: {
14917                         break; }
14918
14919                 }
14920         }
14921         if (ndr_flags & NDR_BUFFERS) {
14922                 int level = ndr_push_get_switch_value(ndr, r);
14923                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14924                 switch (level) {
14925                         case 1:
14926                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14927                         break;
14928
14929                         default:
14930                         break;
14931
14932                 }
14933         }
14934         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14935         return NDR_ERR_SUCCESS;
14936 }
14937
14938 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14939 {
14940         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14941         int level;
14942         level = ndr_pull_get_switch_value(ndr, r);
14943         if (ndr_flags & NDR_SCALARS) {
14944                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14945                 switch (level) {
14946                         case 1: {
14947                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14948                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14949                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14950                         break; }
14951
14952                         default: {
14953                         break; }
14954
14955                 }
14956         }
14957         if (ndr_flags & NDR_BUFFERS) {
14958                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14959                 switch (level) {
14960                         case 1:
14961                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14962                         break;
14963
14964                         default:
14965                         break;
14966
14967                 }
14968         }
14969         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14970         return NDR_ERR_SUCCESS;
14971 }
14972
14973 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14974 {
14975         int level;
14976         level = ndr_print_get_switch_value(ndr, r);
14977         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14978         switch (level) {
14979                 case 1:
14980                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14981                 break;
14982
14983                 default:
14984                 break;
14985
14986         }
14987 }
14988
14989 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14990 {
14991         if (ndr_flags & NDR_SCALARS) {
14992                 NDR_CHECK(ndr_push_align(ndr, 4));
14993                 {
14994                         uint32_t _flags_save_string = ndr->flags;
14995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14996                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14997                         ndr->flags = _flags_save_string;
14998                 }
14999                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15000         }
15001         if (ndr_flags & NDR_BUFFERS) {
15002         }
15003         return NDR_ERR_SUCCESS;
15004 }
15005
15006 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15007 {
15008         if (ndr_flags & NDR_SCALARS) {
15009                 NDR_CHECK(ndr_pull_align(ndr, 4));
15010                 {
15011                         uint32_t _flags_save_string = ndr->flags;
15012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15013                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15014                         ndr->flags = _flags_save_string;
15015                 }
15016                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15017         }
15018         if (ndr_flags & NDR_BUFFERS) {
15019         }
15020         return NDR_ERR_SUCCESS;
15021 }
15022
15023 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15024 {
15025         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15026         ndr->depth++;
15027         ndr_print_string(ndr, "directory_name", r->directory_name);
15028         ndr->depth--;
15029 }
15030
15031 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15032 {
15033         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15034 }
15035
15036 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15037 {
15038         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15039         if (ndr_flags & NDR_SCALARS) {
15040                 int level = ndr_push_get_switch_value(ndr, r);
15041                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15042                 switch (level) {
15043                         case 1: {
15044                                 NDR_CHECK(ndr_push_align(ndr, 4));
15045                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15046                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15047                         break; }
15048
15049                         default: {
15050                                 NDR_CHECK(ndr_push_align(ndr, 4));
15051                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15052                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15053                         break; }
15054
15055                 }
15056         }
15057         if (ndr_flags & NDR_BUFFERS) {
15058                 int level = ndr_push_get_switch_value(ndr, r);
15059                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15060                 switch (level) {
15061                         case 1:
15062                         break;
15063
15064                         default:
15065                         break;
15066
15067                 }
15068         }
15069         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15070         return NDR_ERR_SUCCESS;
15071 }
15072
15073 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15074 {
15075         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15076         int level;
15077         level = ndr_pull_get_switch_value(ndr, r);
15078         if (ndr_flags & NDR_SCALARS) {
15079                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15080                 switch (level) {
15081                         case 1: {
15082                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15083                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15084                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15085                         break; }
15086
15087                         default: {
15088                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15089                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15090                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15091                         break; }
15092
15093                 }
15094         }
15095         if (ndr_flags & NDR_BUFFERS) {
15096                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15097                 switch (level) {
15098                         case 1:
15099                         break;
15100
15101                         default:
15102                         break;
15103
15104                 }
15105         }
15106         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15107         return NDR_ERR_SUCCESS;
15108 }
15109
15110 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15111 {
15112         int level;
15113         level = ndr_print_get_switch_value(ndr, r);
15114         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15115         switch (level) {
15116                 case 1:
15117                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15118                 break;
15119
15120                 default:
15121                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15122                 break;
15123
15124         }
15125 }
15126
15127 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15128 {
15129         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15130 }
15131
15132 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15133 {
15134         if (ndr_flags & NDR_SCALARS) {
15135                 NDR_CHECK(ndr_push_align(ndr, 5));
15136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15139                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15140         }
15141         if (ndr_flags & NDR_BUFFERS) {
15142                 if (r->document_name) {
15143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15146                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15147                 }
15148                 if (r->output_file) {
15149                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15151                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15152                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15153                 }
15154                 if (r->datatype) {
15155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15158                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15159                 }
15160         }
15161         return NDR_ERR_SUCCESS;
15162 }
15163
15164 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15165 {
15166         uint32_t _ptr_document_name;
15167         TALLOC_CTX *_mem_save_document_name_0;
15168         uint32_t _ptr_output_file;
15169         TALLOC_CTX *_mem_save_output_file_0;
15170         uint32_t _ptr_datatype;
15171         TALLOC_CTX *_mem_save_datatype_0;
15172         if (ndr_flags & NDR_SCALARS) {
15173                 NDR_CHECK(ndr_pull_align(ndr, 5));
15174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15175                 if (_ptr_document_name) {
15176                         NDR_PULL_ALLOC(ndr, r->document_name);
15177                 } else {
15178                         r->document_name = NULL;
15179                 }
15180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15181                 if (_ptr_output_file) {
15182                         NDR_PULL_ALLOC(ndr, r->output_file);
15183                 } else {
15184                         r->output_file = NULL;
15185                 }
15186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15187                 if (_ptr_datatype) {
15188                         NDR_PULL_ALLOC(ndr, r->datatype);
15189                 } else {
15190                         r->datatype = NULL;
15191                 }
15192                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15193         }
15194         if (ndr_flags & NDR_BUFFERS) {
15195                 if (r->document_name) {
15196                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15197                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15198                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15199                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15200                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15201                                 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));
15202                         }
15203                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15204                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15206                 }
15207                 if (r->output_file) {
15208                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15209                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15210                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15211                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15212                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15213                                 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));
15214                         }
15215                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15216                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15218                 }
15219                 if (r->datatype) {
15220                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15221                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15222                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15223                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15224                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15225                                 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));
15226                         }
15227                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15228                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15230                 }
15231         }
15232         return NDR_ERR_SUCCESS;
15233 }
15234
15235 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15236 {
15237         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15238         ndr->depth++;
15239         ndr_print_ptr(ndr, "document_name", r->document_name);
15240         ndr->depth++;
15241         if (r->document_name) {
15242                 ndr_print_string(ndr, "document_name", r->document_name);
15243         }
15244         ndr->depth--;
15245         ndr_print_ptr(ndr, "output_file", r->output_file);
15246         ndr->depth++;
15247         if (r->output_file) {
15248                 ndr_print_string(ndr, "output_file", r->output_file);
15249         }
15250         ndr->depth--;
15251         ndr_print_ptr(ndr, "datatype", r->datatype);
15252         ndr->depth++;
15253         if (r->datatype) {
15254                 ndr_print_string(ndr, "datatype", r->datatype);
15255         }
15256         ndr->depth--;
15257         ndr->depth--;
15258 }
15259
15260 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15261 {
15262         if (ndr_flags & NDR_SCALARS) {
15263                 int level = ndr_push_get_switch_value(ndr, r);
15264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15265                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15266                 switch (level) {
15267                         case 1: {
15268                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15269                         break; }
15270
15271                         case 2: {
15272                         break; }
15273
15274                         case 3: {
15275                         break; }
15276
15277                         default: {
15278                         break; }
15279
15280                 }
15281         }
15282         if (ndr_flags & NDR_BUFFERS) {
15283                 int level = ndr_push_get_switch_value(ndr, r);
15284                 switch (level) {
15285                         case 1:
15286                                 if (r->info1) {
15287                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15288                                 }
15289                         break;
15290
15291                         case 2:
15292                         break;
15293
15294                         case 3:
15295                         break;
15296
15297                         default:
15298                         break;
15299
15300                 }
15301         }
15302         return NDR_ERR_SUCCESS;
15303 }
15304
15305 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15306 {
15307         int level;
15308         uint32_t _level;
15309         TALLOC_CTX *_mem_save_info1_0;
15310         level = ndr_pull_get_switch_value(ndr, r);
15311         if (ndr_flags & NDR_SCALARS) {
15312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15313                 if (_level != level) {
15314                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15315                 }
15316                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15317                 switch (level) {
15318                         case 1: {
15319                                 uint32_t _ptr_info1;
15320                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15321                                 if (_ptr_info1) {
15322                                         NDR_PULL_ALLOC(ndr, r->info1);
15323                                 } else {
15324                                         r->info1 = NULL;
15325                                 }
15326                         break; }
15327
15328                         case 2: {
15329                         break; }
15330
15331                         case 3: {
15332                         break; }
15333
15334                         default: {
15335                         break; }
15336
15337                 }
15338         }
15339         if (ndr_flags & NDR_BUFFERS) {
15340                 switch (level) {
15341                         case 1:
15342                                 if (r->info1) {
15343                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15344                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15345                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15346                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15347                                 }
15348                         break;
15349
15350                         case 2:
15351                         break;
15352
15353                         case 3:
15354                         break;
15355
15356                         default:
15357                         break;
15358
15359                 }
15360         }
15361         return NDR_ERR_SUCCESS;
15362 }
15363
15364 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15365 {
15366         int level;
15367         level = ndr_print_get_switch_value(ndr, r);
15368         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15369         switch (level) {
15370                 case 1:
15371                         ndr_print_ptr(ndr, "info1", r->info1);
15372                         ndr->depth++;
15373                         if (r->info1) {
15374                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15375                         }
15376                         ndr->depth--;
15377                 break;
15378
15379                 case 2:
15380                 break;
15381
15382                 case 3:
15383                 break;
15384
15385                 default:
15386                 break;
15387
15388         }
15389 }
15390
15391 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15392 {
15393         if (ndr_flags & NDR_SCALARS) {
15394                 NDR_CHECK(ndr_push_align(ndr, 4));
15395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15400                 {
15401                         uint32_t _flags_save_string = ndr->flags;
15402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15403                         {
15404                                 struct ndr_push *_ndr_extra_string;
15405                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15406                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15407                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15408                         }
15409                         ndr->flags = _flags_save_string;
15410                 }
15411                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15412         }
15413         if (ndr_flags & NDR_BUFFERS) {
15414         }
15415         return NDR_ERR_SUCCESS;
15416 }
15417
15418 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15419 {
15420         if (ndr_flags & NDR_SCALARS) {
15421                 NDR_CHECK(ndr_pull_align(ndr, 4));
15422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15427                 {
15428                         uint32_t _flags_save_string = ndr->flags;
15429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15430                         {
15431                                 struct ndr_pull *_ndr_extra_string;
15432                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15433                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15434                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15435                         }
15436                         ndr->flags = _flags_save_string;
15437                 }
15438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15439         }
15440         if (ndr_flags & NDR_BUFFERS) {
15441         }
15442         return NDR_ERR_SUCCESS;
15443 }
15444
15445 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15446 {
15447         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15448         ndr->depth++;
15449         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);
15450         ndr_print_uint32(ndr, "major", r->major);
15451         ndr_print_uint32(ndr, "minor", r->minor);
15452         ndr_print_uint32(ndr, "build", r->build);
15453         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15454         ndr_print_string(ndr, "extra_string", r->extra_string);
15455         ndr->depth--;
15456 }
15457
15458 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15459 {
15460         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15461 }
15462
15463 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15464 {
15465         if (ndr_flags & NDR_SCALARS) {
15466                 NDR_CHECK(ndr_push_align(ndr, 4));
15467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15472                 {
15473                         uint32_t _flags_save_string = ndr->flags;
15474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15475                         {
15476                                 struct ndr_push *_ndr_extra_string;
15477                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15478                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15479                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15480                         }
15481                         ndr->flags = _flags_save_string;
15482                 }
15483                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15484                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15485                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15486                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15487                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15488                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15489         }
15490         if (ndr_flags & NDR_BUFFERS) {
15491         }
15492         return NDR_ERR_SUCCESS;
15493 }
15494
15495 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15496 {
15497         if (ndr_flags & NDR_SCALARS) {
15498                 NDR_CHECK(ndr_pull_align(ndr, 4));
15499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15504                 {
15505                         uint32_t _flags_save_string = ndr->flags;
15506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15507                         {
15508                                 struct ndr_pull *_ndr_extra_string;
15509                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15510                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15511                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15512                         }
15513                         ndr->flags = _flags_save_string;
15514                 }
15515                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15516                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15517                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15518                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15519                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15520                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15521         }
15522         if (ndr_flags & NDR_BUFFERS) {
15523         }
15524         return NDR_ERR_SUCCESS;
15525 }
15526
15527 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15528 {
15529         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15530         ndr->depth++;
15531         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);
15532         ndr_print_uint32(ndr, "major", r->major);
15533         ndr_print_uint32(ndr, "minor", r->minor);
15534         ndr_print_uint32(ndr, "build", r->build);
15535         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15536         ndr_print_string(ndr, "extra_string", r->extra_string);
15537         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15538         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15539         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15540         ndr_print_uint8(ndr, "product_type", r->product_type);
15541         ndr_print_uint8(ndr, "reserved", r->reserved);
15542         ndr->depth--;
15543 }
15544
15545 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15546 {
15547         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15548 }
15549
15550 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15551 {
15552         if (ndr_flags & NDR_SCALARS) {
15553                 int level = ndr_push_get_switch_value(ndr, r);
15554                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15555                 switch (level) {
15556                         case REG_NONE: {
15557                         break; }
15558
15559                         case REG_SZ: {
15560                                 {
15561                                         uint32_t _flags_save_string = ndr->flags;
15562                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15563                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15564                                         ndr->flags = _flags_save_string;
15565                                 }
15566                         break; }
15567
15568                         case REG_BINARY: {
15569                                 {
15570                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15571                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15572                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15573                                         ndr->flags = _flags_save_DATA_BLOB;
15574                                 }
15575                         break; }
15576
15577                         case REG_DWORD: {
15578                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15579                         break; }
15580
15581                         case REG_MULTI_SZ: {
15582                                 {
15583                                         uint32_t _flags_save_string_array = ndr->flags;
15584                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15585                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15586                                         ndr->flags = _flags_save_string_array;
15587                                 }
15588                         break; }
15589
15590                         default: {
15591                                 {
15592                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15593                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15594                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15595                                         ndr->flags = _flags_save_DATA_BLOB;
15596                                 }
15597                         break; }
15598
15599                 }
15600         }
15601         if (ndr_flags & NDR_BUFFERS) {
15602                 int level = ndr_push_get_switch_value(ndr, r);
15603                 switch (level) {
15604                         case REG_NONE:
15605                         break;
15606
15607                         case REG_SZ:
15608                         break;
15609
15610                         case REG_BINARY:
15611                         break;
15612
15613                         case REG_DWORD:
15614                         break;
15615
15616                         case REG_MULTI_SZ:
15617                         break;
15618
15619                         default:
15620                         break;
15621
15622                 }
15623         }
15624         return NDR_ERR_SUCCESS;
15625 }
15626
15627 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15628 {
15629         int level;
15630         level = ndr_pull_get_switch_value(ndr, r);
15631         if (ndr_flags & NDR_SCALARS) {
15632                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15633                 switch (level) {
15634                         case REG_NONE: {
15635                         break; }
15636
15637                         case REG_SZ: {
15638                                 {
15639                                         uint32_t _flags_save_string = ndr->flags;
15640                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15641                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15642                                         ndr->flags = _flags_save_string;
15643                                 }
15644                         break; }
15645
15646                         case REG_BINARY: {
15647                                 {
15648                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15649                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15650                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15651                                         ndr->flags = _flags_save_DATA_BLOB;
15652                                 }
15653                         break; }
15654
15655                         case REG_DWORD: {
15656                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15657                         break; }
15658
15659                         case REG_MULTI_SZ: {
15660                                 {
15661                                         uint32_t _flags_save_string_array = ndr->flags;
15662                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15663                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15664                                         ndr->flags = _flags_save_string_array;
15665                                 }
15666                         break; }
15667
15668                         default: {
15669                                 {
15670                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15671                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15672                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15673                                         ndr->flags = _flags_save_DATA_BLOB;
15674                                 }
15675                         break; }
15676
15677                 }
15678         }
15679         if (ndr_flags & NDR_BUFFERS) {
15680                 switch (level) {
15681                         case REG_NONE:
15682                         break;
15683
15684                         case REG_SZ:
15685                         break;
15686
15687                         case REG_BINARY:
15688                         break;
15689
15690                         case REG_DWORD:
15691                         break;
15692
15693                         case REG_MULTI_SZ:
15694                         break;
15695
15696                         default:
15697                         break;
15698
15699                 }
15700         }
15701         return NDR_ERR_SUCCESS;
15702 }
15703
15704 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15705 {
15706         int level;
15707         level = ndr_print_get_switch_value(ndr, r);
15708         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15709         switch (level) {
15710                 case REG_NONE:
15711                 break;
15712
15713                 case REG_SZ:
15714                         ndr_print_string(ndr, "string", r->string);
15715                 break;
15716
15717                 case REG_BINARY:
15718                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15719                 break;
15720
15721                 case REG_DWORD:
15722                         ndr_print_uint32(ndr, "value", r->value);
15723                 break;
15724
15725                 case REG_MULTI_SZ:
15726                         ndr_print_string_array(ndr, "string_array", r->string_array);
15727                 break;
15728
15729                 default:
15730                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15731                 break;
15732
15733         }
15734 }
15735
15736 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15737 {
15738         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
15739 }
15740
15741 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15742 {
15743         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15744         return NDR_ERR_SUCCESS;
15745 }
15746
15747 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15748 {
15749         uint32_t v;
15750         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15751         *r = v;
15752         return NDR_ERR_SUCCESS;
15753 }
15754
15755 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15756 {
15757         const char *val = NULL;
15758
15759         switch (r) {
15760                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15761                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15762                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15763         }
15764         ndr_print_enum(ndr, name, "ENUM", val, r);
15765 }
15766
15767 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15768 {
15769         if (ndr_flags & NDR_SCALARS) {
15770                 NDR_CHECK(ndr_push_align(ndr, 4));
15771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15773                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15774         }
15775         if (ndr_flags & NDR_BUFFERS) {
15776         }
15777         return NDR_ERR_SUCCESS;
15778 }
15779
15780 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15781 {
15782         if (ndr_flags & NDR_SCALARS) {
15783                 NDR_CHECK(ndr_pull_align(ndr, 4));
15784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15786                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15787         }
15788         if (ndr_flags & NDR_BUFFERS) {
15789         }
15790         return NDR_ERR_SUCCESS;
15791 }
15792
15793 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15794 {
15795         ndr_print_struct(ndr, name, "spoolss_FormSize");
15796         ndr->depth++;
15797         ndr_print_uint32(ndr, "width", r->width);
15798         ndr_print_uint32(ndr, "height", r->height);
15799         ndr->depth--;
15800 }
15801
15802 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15803 {
15804         if (ndr_flags & NDR_SCALARS) {
15805                 NDR_CHECK(ndr_push_align(ndr, 4));
15806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15810                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15811         }
15812         if (ndr_flags & NDR_BUFFERS) {
15813         }
15814         return NDR_ERR_SUCCESS;
15815 }
15816
15817 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15818 {
15819         if (ndr_flags & NDR_SCALARS) {
15820                 NDR_CHECK(ndr_pull_align(ndr, 4));
15821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15825                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15826         }
15827         if (ndr_flags & NDR_BUFFERS) {
15828         }
15829         return NDR_ERR_SUCCESS;
15830 }
15831
15832 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15833 {
15834         ndr_print_struct(ndr, name, "spoolss_FormArea");
15835         ndr->depth++;
15836         ndr_print_uint32(ndr, "left", r->left);
15837         ndr_print_uint32(ndr, "top", r->top);
15838         ndr_print_uint32(ndr, "right", r->right);
15839         ndr_print_uint32(ndr, "bottom", r->bottom);
15840         ndr->depth--;
15841 }
15842
15843 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15844 {
15845         if (ndr_flags & NDR_SCALARS) {
15846                 NDR_CHECK(ndr_push_align(ndr, 5));
15847                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15848                 {
15849                         uint32_t _flags_save_string = ndr->flags;
15850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15851                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15852                         ndr->flags = _flags_save_string;
15853                 }
15854                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15855                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15856                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15857         }
15858         if (ndr_flags & NDR_BUFFERS) {
15859                 {
15860                         uint32_t _flags_save_string = ndr->flags;
15861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15862                         if (r->form_name) {
15863                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15864                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15865                         }
15866                         ndr->flags = _flags_save_string;
15867                 }
15868         }
15869         return NDR_ERR_SUCCESS;
15870 }
15871
15872 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15873 {
15874         uint32_t _ptr_form_name;
15875         TALLOC_CTX *_mem_save_form_name_0;
15876         if (ndr_flags & NDR_SCALARS) {
15877                 NDR_CHECK(ndr_pull_align(ndr, 5));
15878                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15879                 {
15880                         uint32_t _flags_save_string = ndr->flags;
15881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15883                         if (_ptr_form_name) {
15884                                 NDR_PULL_ALLOC(ndr, r->form_name);
15885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15886                         } else {
15887                                 r->form_name = NULL;
15888                         }
15889                         ndr->flags = _flags_save_string;
15890                 }
15891                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15892                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15893                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15894         }
15895         if (ndr_flags & NDR_BUFFERS) {
15896                 {
15897                         uint32_t _flags_save_string = ndr->flags;
15898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15899                         if (r->form_name) {
15900                                 uint32_t _relative_save_offset;
15901                                 _relative_save_offset = ndr->offset;
15902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15903                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15904                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15907                                 if (ndr->offset > ndr->relative_highest_offset) {
15908                                         ndr->relative_highest_offset = ndr->offset;
15909                                 }
15910                                 ndr->offset = _relative_save_offset;
15911                         }
15912                         ndr->flags = _flags_save_string;
15913                 }
15914         }
15915         return NDR_ERR_SUCCESS;
15916 }
15917
15918 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15919 {
15920         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15921         ndr->depth++;
15922         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15923         ndr_print_ptr(ndr, "form_name", r->form_name);
15924         ndr->depth++;
15925         if (r->form_name) {
15926                 ndr_print_string(ndr, "form_name", r->form_name);
15927         }
15928         ndr->depth--;
15929         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15930         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15931         ndr->depth--;
15932 }
15933
15934 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15935 {
15936         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15937 }
15938
15939 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15940 {
15941         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15942         return NDR_ERR_SUCCESS;
15943 }
15944
15945 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15946 {
15947         uint32_t v;
15948         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15949         *r = v;
15950         return NDR_ERR_SUCCESS;
15951 }
15952
15953 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15954 {
15955         ndr_print_uint32(ndr, name, r);
15956         ndr->depth++;
15957         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15960         ndr->depth--;
15961 }
15962
15963 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15964 {
15965         if (ndr_flags & NDR_SCALARS) {
15966                 NDR_CHECK(ndr_push_align(ndr, 5));
15967                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15968                 {
15969                         uint32_t _flags_save_string = ndr->flags;
15970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15971                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15972                         ndr->flags = _flags_save_string;
15973                 }
15974                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15975                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15976                 {
15977                         uint32_t _flags_save_string = ndr->flags;
15978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15979                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15980                         ndr->flags = _flags_save_string;
15981                 }
15982                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15983                 {
15984                         uint32_t _flags_save_string = ndr->flags;
15985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15986                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15987                         ndr->flags = _flags_save_string;
15988                 }
15989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15990                 {
15991                         uint32_t _flags_save_string = ndr->flags;
15992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15994                         ndr->flags = _flags_save_string;
15995                 }
15996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15997                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15998         }
15999         if (ndr_flags & NDR_BUFFERS) {
16000                 {
16001                         uint32_t _flags_save_string = ndr->flags;
16002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16003                         if (r->form_name) {
16004                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
16005                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
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_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16012                         if (r->keyword) {
16013                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
16014                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
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->mui_dll) {
16022                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
16023                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16024                         }
16025                         ndr->flags = _flags_save_string;
16026                 }
16027                 {
16028                         uint32_t _flags_save_string = ndr->flags;
16029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16030                         if (r->display_name) {
16031                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
16032                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16033                         }
16034                         ndr->flags = _flags_save_string;
16035                 }
16036         }
16037         return NDR_ERR_SUCCESS;
16038 }
16039
16040 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16041 {
16042         uint32_t _ptr_form_name;
16043         TALLOC_CTX *_mem_save_form_name_0;
16044         uint32_t _ptr_keyword;
16045         TALLOC_CTX *_mem_save_keyword_0;
16046         uint32_t _ptr_mui_dll;
16047         TALLOC_CTX *_mem_save_mui_dll_0;
16048         uint32_t _ptr_display_name;
16049         TALLOC_CTX *_mem_save_display_name_0;
16050         if (ndr_flags & NDR_SCALARS) {
16051                 NDR_CHECK(ndr_pull_align(ndr, 5));
16052                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16053                 {
16054                         uint32_t _flags_save_string = ndr->flags;
16055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16056                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16057                         if (_ptr_form_name) {
16058                                 NDR_PULL_ALLOC(ndr, r->form_name);
16059                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16060                         } else {
16061                                 r->form_name = NULL;
16062                         }
16063                         ndr->flags = _flags_save_string;
16064                 }
16065                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16066                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16067                 {
16068                         uint32_t _flags_save_string = ndr->flags;
16069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16070                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16071                         if (_ptr_keyword) {
16072                                 NDR_PULL_ALLOC(ndr, r->keyword);
16073                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16074                         } else {
16075                                 r->keyword = NULL;
16076                         }
16077                         ndr->flags = _flags_save_string;
16078                 }
16079                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16080                 {
16081                         uint32_t _flags_save_string = ndr->flags;
16082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16083                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16084                         if (_ptr_mui_dll) {
16085                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16086                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16087                         } else {
16088                                 r->mui_dll = NULL;
16089                         }
16090                         ndr->flags = _flags_save_string;
16091                 }
16092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16093                 {
16094                         uint32_t _flags_save_string = ndr->flags;
16095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16096                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16097                         if (_ptr_display_name) {
16098                                 NDR_PULL_ALLOC(ndr, r->display_name);
16099                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16100                         } else {
16101                                 r->display_name = NULL;
16102                         }
16103                         ndr->flags = _flags_save_string;
16104                 }
16105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16106                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16107         }
16108         if (ndr_flags & NDR_BUFFERS) {
16109                 {
16110                         uint32_t _flags_save_string = ndr->flags;
16111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16112                         if (r->form_name) {
16113                                 uint32_t _relative_save_offset;
16114                                 _relative_save_offset = ndr->offset;
16115                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16116                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16117                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16118                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16119                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16120                                 if (ndr->offset > ndr->relative_highest_offset) {
16121                                         ndr->relative_highest_offset = ndr->offset;
16122                                 }
16123                                 ndr->offset = _relative_save_offset;
16124                         }
16125                         ndr->flags = _flags_save_string;
16126                 }
16127                 {
16128                         uint32_t _flags_save_string = ndr->flags;
16129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16130                         if (r->keyword) {
16131                                 uint32_t _relative_save_offset;
16132                                 _relative_save_offset = ndr->offset;
16133                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16134                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16135                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16136                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16137                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16138                                 if (ndr->offset > ndr->relative_highest_offset) {
16139                                         ndr->relative_highest_offset = ndr->offset;
16140                                 }
16141                                 ndr->offset = _relative_save_offset;
16142                         }
16143                         ndr->flags = _flags_save_string;
16144                 }
16145                 {
16146                         uint32_t _flags_save_string = ndr->flags;
16147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16148                         if (r->mui_dll) {
16149                                 uint32_t _relative_save_offset;
16150                                 _relative_save_offset = ndr->offset;
16151                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16152                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16153                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16154                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16155                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16156                                 if (ndr->offset > ndr->relative_highest_offset) {
16157                                         ndr->relative_highest_offset = ndr->offset;
16158                                 }
16159                                 ndr->offset = _relative_save_offset;
16160                         }
16161                         ndr->flags = _flags_save_string;
16162                 }
16163                 {
16164                         uint32_t _flags_save_string = ndr->flags;
16165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16166                         if (r->display_name) {
16167                                 uint32_t _relative_save_offset;
16168                                 _relative_save_offset = ndr->offset;
16169                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16170                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16171                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16172                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16173                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16174                                 if (ndr->offset > ndr->relative_highest_offset) {
16175                                         ndr->relative_highest_offset = ndr->offset;
16176                                 }
16177                                 ndr->offset = _relative_save_offset;
16178                         }
16179                         ndr->flags = _flags_save_string;
16180                 }
16181         }
16182         return NDR_ERR_SUCCESS;
16183 }
16184
16185 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16186 {
16187         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16188         ndr->depth++;
16189         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16190         ndr_print_ptr(ndr, "form_name", r->form_name);
16191         ndr->depth++;
16192         if (r->form_name) {
16193                 ndr_print_string(ndr, "form_name", r->form_name);
16194         }
16195         ndr->depth--;
16196         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16197         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16198         ndr_print_ptr(ndr, "keyword", r->keyword);
16199         ndr->depth++;
16200         if (r->keyword) {
16201                 ndr_print_string(ndr, "keyword", r->keyword);
16202         }
16203         ndr->depth--;
16204         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16205         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16206         ndr->depth++;
16207         if (r->mui_dll) {
16208                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16209         }
16210         ndr->depth--;
16211         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16212         ndr_print_ptr(ndr, "display_name", r->display_name);
16213         ndr->depth++;
16214         if (r->display_name) {
16215                 ndr_print_string(ndr, "display_name", r->display_name);
16216         }
16217         ndr->depth--;
16218         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16219         ndr->depth--;
16220 }
16221
16222 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16223 {
16224         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16225 }
16226
16227 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16228 {
16229         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16230         if (ndr_flags & NDR_SCALARS) {
16231                 int level = ndr_push_get_switch_value(ndr, r);
16232                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16233                 switch (level) {
16234                         case 1: {
16235                                 NDR_CHECK(ndr_push_align(ndr, 5));
16236                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16237                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16238                         break; }
16239
16240                         case 2: {
16241                                 NDR_CHECK(ndr_push_align(ndr, 5));
16242                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16243                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16244                         break; }
16245
16246                         default: {
16247                         break; }
16248
16249                 }
16250         }
16251         if (ndr_flags & NDR_BUFFERS) {
16252                 int level = ndr_push_get_switch_value(ndr, r);
16253                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16254                 switch (level) {
16255                         case 1:
16256                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16257                         break;
16258
16259                         case 2:
16260                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16261                         break;
16262
16263                         default:
16264                         break;
16265
16266                 }
16267         }
16268         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16269         return NDR_ERR_SUCCESS;
16270 }
16271
16272 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16273 {
16274         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16275         int level;
16276         level = ndr_pull_get_switch_value(ndr, r);
16277         if (ndr_flags & NDR_SCALARS) {
16278                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16279                 switch (level) {
16280                         case 1: {
16281                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16282                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16283                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16284                         break; }
16285
16286                         case 2: {
16287                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16288                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16289                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16290                         break; }
16291
16292                         default: {
16293                         break; }
16294
16295                 }
16296         }
16297         if (ndr_flags & NDR_BUFFERS) {
16298                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16299                 switch (level) {
16300                         case 1:
16301                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16302                         break;
16303
16304                         case 2:
16305                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16306                         break;
16307
16308                         default:
16309                         break;
16310
16311                 }
16312         }
16313         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16314         return NDR_ERR_SUCCESS;
16315 }
16316
16317 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16318 {
16319         int level;
16320         level = ndr_print_get_switch_value(ndr, r);
16321         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16322         switch (level) {
16323                 case 1:
16324                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16325                 break;
16326
16327                 case 2:
16328                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16329                 break;
16330
16331                 default:
16332                 break;
16333
16334         }
16335 }
16336
16337 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16338 {
16339         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16340 }
16341
16342 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16343 {
16344         if (ndr_flags & NDR_SCALARS) {
16345                 NDR_CHECK(ndr_push_align(ndr, 5));
16346                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16348                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16349                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16350                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16351         }
16352         if (ndr_flags & NDR_BUFFERS) {
16353                 if (r->form_name) {
16354                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16355                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16356                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16358                 }
16359         }
16360         return NDR_ERR_SUCCESS;
16361 }
16362
16363 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16364 {
16365         uint32_t _ptr_form_name;
16366         TALLOC_CTX *_mem_save_form_name_0;
16367         if (ndr_flags & NDR_SCALARS) {
16368                 NDR_CHECK(ndr_pull_align(ndr, 5));
16369                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16371                 if (_ptr_form_name) {
16372                         NDR_PULL_ALLOC(ndr, r->form_name);
16373                 } else {
16374                         r->form_name = NULL;
16375                 }
16376                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16377                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16378                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16379         }
16380         if (ndr_flags & NDR_BUFFERS) {
16381                 if (r->form_name) {
16382                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16383                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16386                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16387                                 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));
16388                         }
16389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16392                 }
16393         }
16394         return NDR_ERR_SUCCESS;
16395 }
16396
16397 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16398 {
16399         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16400         ndr->depth++;
16401         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16402         ndr_print_ptr(ndr, "form_name", r->form_name);
16403         ndr->depth++;
16404         if (r->form_name) {
16405                 ndr_print_string(ndr, "form_name", r->form_name);
16406         }
16407         ndr->depth--;
16408         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16409         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16410         ndr->depth--;
16411 }
16412
16413 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16414 {
16415         if (ndr_flags & NDR_SCALARS) {
16416                 NDR_CHECK(ndr_push_align(ndr, 5));
16417                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16419                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16420                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16422                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16427                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16428         }
16429         if (ndr_flags & NDR_BUFFERS) {
16430                 if (r->form_name) {
16431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16435                 }
16436                 if (r->keyword) {
16437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16441                 }
16442                 if (r->mui_dll) {
16443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16444                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16447                 }
16448                 if (r->display_name) {
16449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16453                 }
16454         }
16455         return NDR_ERR_SUCCESS;
16456 }
16457
16458 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16459 {
16460         uint32_t _ptr_form_name;
16461         TALLOC_CTX *_mem_save_form_name_0;
16462         uint32_t _ptr_keyword;
16463         TALLOC_CTX *_mem_save_keyword_0;
16464         uint32_t _ptr_mui_dll;
16465         TALLOC_CTX *_mem_save_mui_dll_0;
16466         uint32_t _ptr_display_name;
16467         TALLOC_CTX *_mem_save_display_name_0;
16468         if (ndr_flags & NDR_SCALARS) {
16469                 NDR_CHECK(ndr_pull_align(ndr, 5));
16470                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16472                 if (_ptr_form_name) {
16473                         NDR_PULL_ALLOC(ndr, r->form_name);
16474                 } else {
16475                         r->form_name = NULL;
16476                 }
16477                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16478                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16480                 if (_ptr_keyword) {
16481                         NDR_PULL_ALLOC(ndr, r->keyword);
16482                 } else {
16483                         r->keyword = NULL;
16484                 }
16485                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16487                 if (_ptr_mui_dll) {
16488                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16489                 } else {
16490                         r->mui_dll = NULL;
16491                 }
16492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16494                 if (_ptr_display_name) {
16495                         NDR_PULL_ALLOC(ndr, r->display_name);
16496                 } else {
16497                         r->display_name = NULL;
16498                 }
16499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16500                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16501         }
16502         if (ndr_flags & NDR_BUFFERS) {
16503                 if (r->form_name) {
16504                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16505                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16508                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16509                                 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));
16510                         }
16511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16514                 }
16515                 if (r->keyword) {
16516                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16517                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16518                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16519                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16520                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16521                                 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));
16522                         }
16523                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16524                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16526                 }
16527                 if (r->mui_dll) {
16528                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16529                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16530                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16531                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16532                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16533                                 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));
16534                         }
16535                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16536                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16538                 }
16539                 if (r->display_name) {
16540                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16541                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16542                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16543                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16544                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16545                                 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));
16546                         }
16547                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16548                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16550                 }
16551         }
16552         return NDR_ERR_SUCCESS;
16553 }
16554
16555 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16556 {
16557         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16558         ndr->depth++;
16559         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16560         ndr_print_ptr(ndr, "form_name", r->form_name);
16561         ndr->depth++;
16562         if (r->form_name) {
16563                 ndr_print_string(ndr, "form_name", r->form_name);
16564         }
16565         ndr->depth--;
16566         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16567         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16568         ndr_print_ptr(ndr, "keyword", r->keyword);
16569         ndr->depth++;
16570         if (r->keyword) {
16571                 ndr_print_string(ndr, "keyword", r->keyword);
16572         }
16573         ndr->depth--;
16574         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16575         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16576         ndr->depth++;
16577         if (r->mui_dll) {
16578                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16579         }
16580         ndr->depth--;
16581         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16582         ndr_print_ptr(ndr, "display_name", r->display_name);
16583         ndr->depth++;
16584         if (r->display_name) {
16585                 ndr_print_string(ndr, "display_name", r->display_name);
16586         }
16587         ndr->depth--;
16588         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16589         ndr->depth--;
16590 }
16591
16592 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16593 {
16594         if (ndr_flags & NDR_SCALARS) {
16595                 int level = ndr_push_get_switch_value(ndr, r);
16596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16597                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16598                 switch (level) {
16599                         case 1: {
16600                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16601                         break; }
16602
16603                         case 2: {
16604                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16605                         break; }
16606
16607                         default:
16608                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16609                 }
16610         }
16611         if (ndr_flags & NDR_BUFFERS) {
16612                 int level = ndr_push_get_switch_value(ndr, r);
16613                 switch (level) {
16614                         case 1:
16615                                 if (r->info1) {
16616                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16617                                 }
16618                         break;
16619
16620                         case 2:
16621                                 if (r->info2) {
16622                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16623                                 }
16624                         break;
16625
16626                         default:
16627                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16628                 }
16629         }
16630         return NDR_ERR_SUCCESS;
16631 }
16632
16633 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16634 {
16635         int level;
16636         uint32_t _level;
16637         TALLOC_CTX *_mem_save_info1_0;
16638         TALLOC_CTX *_mem_save_info2_0;
16639         level = ndr_pull_get_switch_value(ndr, r);
16640         if (ndr_flags & NDR_SCALARS) {
16641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16642                 if (_level != level) {
16643                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16644                 }
16645                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16646                 switch (level) {
16647                         case 1: {
16648                                 uint32_t _ptr_info1;
16649                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16650                                 if (_ptr_info1) {
16651                                         NDR_PULL_ALLOC(ndr, r->info1);
16652                                 } else {
16653                                         r->info1 = NULL;
16654                                 }
16655                         break; }
16656
16657                         case 2: {
16658                                 uint32_t _ptr_info2;
16659                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16660                                 if (_ptr_info2) {
16661                                         NDR_PULL_ALLOC(ndr, r->info2);
16662                                 } else {
16663                                         r->info2 = NULL;
16664                                 }
16665                         break; }
16666
16667                         default:
16668                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16669                 }
16670         }
16671         if (ndr_flags & NDR_BUFFERS) {
16672                 switch (level) {
16673                         case 1:
16674                                 if (r->info1) {
16675                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16676                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16677                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16678                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16679                                 }
16680                         break;
16681
16682                         case 2:
16683                                 if (r->info2) {
16684                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16685                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16686                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16687                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16688                                 }
16689                         break;
16690
16691                         default:
16692                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16693                 }
16694         }
16695         return NDR_ERR_SUCCESS;
16696 }
16697
16698 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16699 {
16700         int level;
16701         level = ndr_print_get_switch_value(ndr, r);
16702         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16703         switch (level) {
16704                 case 1:
16705                         ndr_print_ptr(ndr, "info1", r->info1);
16706                         ndr->depth++;
16707                         if (r->info1) {
16708                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16709                         }
16710                         ndr->depth--;
16711                 break;
16712
16713                 case 2:
16714                         ndr_print_ptr(ndr, "info2", r->info2);
16715                         ndr->depth++;
16716                         if (r->info2) {
16717                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16718                         }
16719                         ndr->depth--;
16720                 break;
16721
16722                 default:
16723                         ndr_print_bad_level(ndr, name, level);
16724         }
16725 }
16726
16727 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16728 {
16729         if (ndr_flags & NDR_SCALARS) {
16730                 NDR_CHECK(ndr_push_align(ndr, 5));
16731                 {
16732                         uint32_t _flags_save_string = ndr->flags;
16733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16734                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16735                         ndr->flags = _flags_save_string;
16736                 }
16737                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16738         }
16739         if (ndr_flags & NDR_BUFFERS) {
16740                 {
16741                         uint32_t _flags_save_string = ndr->flags;
16742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16743                         if (r->port_name) {
16744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16745                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16746                         }
16747                         ndr->flags = _flags_save_string;
16748                 }
16749         }
16750         return NDR_ERR_SUCCESS;
16751 }
16752
16753 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16754 {
16755         uint32_t _ptr_port_name;
16756         TALLOC_CTX *_mem_save_port_name_0;
16757         if (ndr_flags & NDR_SCALARS) {
16758                 NDR_CHECK(ndr_pull_align(ndr, 5));
16759                 {
16760                         uint32_t _flags_save_string = ndr->flags;
16761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16762                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16763                         if (_ptr_port_name) {
16764                                 NDR_PULL_ALLOC(ndr, r->port_name);
16765                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16766                         } else {
16767                                 r->port_name = NULL;
16768                         }
16769                         ndr->flags = _flags_save_string;
16770                 }
16771                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16772         }
16773         if (ndr_flags & NDR_BUFFERS) {
16774                 {
16775                         uint32_t _flags_save_string = ndr->flags;
16776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16777                         if (r->port_name) {
16778                                 uint32_t _relative_save_offset;
16779                                 _relative_save_offset = ndr->offset;
16780                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16781                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16782                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16783                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16784                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16785                                 if (ndr->offset > ndr->relative_highest_offset) {
16786                                         ndr->relative_highest_offset = ndr->offset;
16787                                 }
16788                                 ndr->offset = _relative_save_offset;
16789                         }
16790                         ndr->flags = _flags_save_string;
16791                 }
16792         }
16793         return NDR_ERR_SUCCESS;
16794 }
16795
16796 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16797 {
16798         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16799         ndr->depth++;
16800         ndr_print_ptr(ndr, "port_name", r->port_name);
16801         ndr->depth++;
16802         if (r->port_name) {
16803                 ndr_print_string(ndr, "port_name", r->port_name);
16804         }
16805         ndr->depth--;
16806         ndr->depth--;
16807 }
16808
16809 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16810 {
16811         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16812 }
16813
16814 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16815 {
16816         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16817         return NDR_ERR_SUCCESS;
16818 }
16819
16820 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16821 {
16822         uint32_t v;
16823         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16824         *r = v;
16825         return NDR_ERR_SUCCESS;
16826 }
16827
16828 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16829 {
16830         ndr_print_uint32(ndr, name, r);
16831         ndr->depth++;
16832         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16833         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16834         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16835         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16836         ndr->depth--;
16837 }
16838
16839 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16840 {
16841         if (ndr_flags & NDR_SCALARS) {
16842                 NDR_CHECK(ndr_push_align(ndr, 5));
16843                 {
16844                         uint32_t _flags_save_string = ndr->flags;
16845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16846                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16847                         ndr->flags = _flags_save_string;
16848                 }
16849                 {
16850                         uint32_t _flags_save_string = ndr->flags;
16851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16852                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16853                         ndr->flags = _flags_save_string;
16854                 }
16855                 {
16856                         uint32_t _flags_save_string = ndr->flags;
16857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16858                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16859                         ndr->flags = _flags_save_string;
16860                 }
16861                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16863                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16864         }
16865         if (ndr_flags & NDR_BUFFERS) {
16866                 {
16867                         uint32_t _flags_save_string = ndr->flags;
16868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16869                         if (r->port_name) {
16870                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16871                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_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->monitor_name) {
16879                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16880                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16881                         }
16882                         ndr->flags = _flags_save_string;
16883                 }
16884                 {
16885                         uint32_t _flags_save_string = ndr->flags;
16886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16887                         if (r->description) {
16888                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
16889                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16890                         }
16891                         ndr->flags = _flags_save_string;
16892                 }
16893         }
16894         return NDR_ERR_SUCCESS;
16895 }
16896
16897 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16898 {
16899         uint32_t _ptr_port_name;
16900         TALLOC_CTX *_mem_save_port_name_0;
16901         uint32_t _ptr_monitor_name;
16902         TALLOC_CTX *_mem_save_monitor_name_0;
16903         uint32_t _ptr_description;
16904         TALLOC_CTX *_mem_save_description_0;
16905         if (ndr_flags & NDR_SCALARS) {
16906                 NDR_CHECK(ndr_pull_align(ndr, 5));
16907                 {
16908                         uint32_t _flags_save_string = ndr->flags;
16909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16911                         if (_ptr_port_name) {
16912                                 NDR_PULL_ALLOC(ndr, r->port_name);
16913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16914                         } else {
16915                                 r->port_name = NULL;
16916                         }
16917                         ndr->flags = _flags_save_string;
16918                 }
16919                 {
16920                         uint32_t _flags_save_string = ndr->flags;
16921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16923                         if (_ptr_monitor_name) {
16924                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16926                         } else {
16927                                 r->monitor_name = NULL;
16928                         }
16929                         ndr->flags = _flags_save_string;
16930                 }
16931                 {
16932                         uint32_t _flags_save_string = ndr->flags;
16933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16934                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16935                         if (_ptr_description) {
16936                                 NDR_PULL_ALLOC(ndr, r->description);
16937                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16938                         } else {
16939                                 r->description = NULL;
16940                         }
16941                         ndr->flags = _flags_save_string;
16942                 }
16943                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16945                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16946         }
16947         if (ndr_flags & NDR_BUFFERS) {
16948                 {
16949                         uint32_t _flags_save_string = ndr->flags;
16950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16951                         if (r->port_name) {
16952                                 uint32_t _relative_save_offset;
16953                                 _relative_save_offset = ndr->offset;
16954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16955                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16956                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16959                                 if (ndr->offset > ndr->relative_highest_offset) {
16960                                         ndr->relative_highest_offset = ndr->offset;
16961                                 }
16962                                 ndr->offset = _relative_save_offset;
16963                         }
16964                         ndr->flags = _flags_save_string;
16965                 }
16966                 {
16967                         uint32_t _flags_save_string = ndr->flags;
16968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16969                         if (r->monitor_name) {
16970                                 uint32_t _relative_save_offset;
16971                                 _relative_save_offset = ndr->offset;
16972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16973                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16974                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16977                                 if (ndr->offset > ndr->relative_highest_offset) {
16978                                         ndr->relative_highest_offset = ndr->offset;
16979                                 }
16980                                 ndr->offset = _relative_save_offset;
16981                         }
16982                         ndr->flags = _flags_save_string;
16983                 }
16984                 {
16985                         uint32_t _flags_save_string = ndr->flags;
16986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16987                         if (r->description) {
16988                                 uint32_t _relative_save_offset;
16989                                 _relative_save_offset = ndr->offset;
16990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
16991                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
16992                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
16993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
16994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
16995                                 if (ndr->offset > ndr->relative_highest_offset) {
16996                                         ndr->relative_highest_offset = ndr->offset;
16997                                 }
16998                                 ndr->offset = _relative_save_offset;
16999                         }
17000                         ndr->flags = _flags_save_string;
17001                 }
17002         }
17003         return NDR_ERR_SUCCESS;
17004 }
17005
17006 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17007 {
17008         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17009         ndr->depth++;
17010         ndr_print_ptr(ndr, "port_name", r->port_name);
17011         ndr->depth++;
17012         if (r->port_name) {
17013                 ndr_print_string(ndr, "port_name", r->port_name);
17014         }
17015         ndr->depth--;
17016         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17017         ndr->depth++;
17018         if (r->monitor_name) {
17019                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17020         }
17021         ndr->depth--;
17022         ndr_print_ptr(ndr, "description", r->description);
17023         ndr->depth++;
17024         if (r->description) {
17025                 ndr_print_string(ndr, "description", r->description);
17026         }
17027         ndr->depth--;
17028         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17029         ndr_print_uint32(ndr, "reserved", r->reserved);
17030         ndr->depth--;
17031 }
17032
17033 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17034 {
17035         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17036 }
17037
17038 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17039 {
17040         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17041         return NDR_ERR_SUCCESS;
17042 }
17043
17044 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17045 {
17046         uint32_t v;
17047         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17048         *r = v;
17049         return NDR_ERR_SUCCESS;
17050 }
17051
17052 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17053 {
17054         const char *val = NULL;
17055
17056         switch (r) {
17057                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17058                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17059                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17060                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17061                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17062                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17063                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17064                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17065                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17066                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17067                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17068                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17069                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17070         }
17071         ndr_print_enum(ndr, name, "ENUM", val, r);
17072 }
17073
17074 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17075 {
17076         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17077         return NDR_ERR_SUCCESS;
17078 }
17079
17080 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17081 {
17082         uint32_t v;
17083         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17084         *r = v;
17085         return NDR_ERR_SUCCESS;
17086 }
17087
17088 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17089 {
17090         const char *val = NULL;
17091
17092         switch (r) {
17093                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17094                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17095                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17096         }
17097         ndr_print_enum(ndr, name, "ENUM", val, r);
17098 }
17099
17100 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17101 {
17102         if (ndr_flags & NDR_SCALARS) {
17103                 NDR_CHECK(ndr_push_align(ndr, 5));
17104                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17105                 {
17106                         uint32_t _flags_save_string = ndr->flags;
17107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17108                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17109                         ndr->flags = _flags_save_string;
17110                 }
17111                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17112                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17113         }
17114         if (ndr_flags & NDR_BUFFERS) {
17115                 {
17116                         uint32_t _flags_save_string = ndr->flags;
17117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17118                         if (r->status_string) {
17119                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
17120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17121                         }
17122                         ndr->flags = _flags_save_string;
17123                 }
17124         }
17125         return NDR_ERR_SUCCESS;
17126 }
17127
17128 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17129 {
17130         uint32_t _ptr_status_string;
17131         TALLOC_CTX *_mem_save_status_string_0;
17132         if (ndr_flags & NDR_SCALARS) {
17133                 NDR_CHECK(ndr_pull_align(ndr, 5));
17134                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17135                 {
17136                         uint32_t _flags_save_string = ndr->flags;
17137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17138                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17139                         if (_ptr_status_string) {
17140                                 NDR_PULL_ALLOC(ndr, r->status_string);
17141                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17142                         } else {
17143                                 r->status_string = NULL;
17144                         }
17145                         ndr->flags = _flags_save_string;
17146                 }
17147                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17148                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17149         }
17150         if (ndr_flags & NDR_BUFFERS) {
17151                 {
17152                         uint32_t _flags_save_string = ndr->flags;
17153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17154                         if (r->status_string) {
17155                                 uint32_t _relative_save_offset;
17156                                 _relative_save_offset = ndr->offset;
17157                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17158                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17159                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17160                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17161                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17162                                 if (ndr->offset > ndr->relative_highest_offset) {
17163                                         ndr->relative_highest_offset = ndr->offset;
17164                                 }
17165                                 ndr->offset = _relative_save_offset;
17166                         }
17167                         ndr->flags = _flags_save_string;
17168                 }
17169         }
17170         return NDR_ERR_SUCCESS;
17171 }
17172
17173 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17174 {
17175         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17176         ndr->depth++;
17177         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17178         ndr_print_ptr(ndr, "status_string", r->status_string);
17179         ndr->depth++;
17180         if (r->status_string) {
17181                 ndr_print_string(ndr, "status_string", r->status_string);
17182         }
17183         ndr->depth--;
17184         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17185         ndr->depth--;
17186 }
17187
17188 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17189 {
17190         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17191 }
17192
17193 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17194 {
17195         if (ndr_flags & NDR_SCALARS) {
17196                 NDR_CHECK(ndr_push_align(ndr, 5));
17197                 {
17198                         uint32_t _flags_save_string = ndr->flags;
17199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17200                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17201                         ndr->flags = _flags_save_string;
17202                 }
17203                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17204                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17205         }
17206         if (ndr_flags & NDR_BUFFERS) {
17207                 {
17208                         uint32_t _flags_save_string = ndr->flags;
17209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17210                         if (r->port_name) {
17211                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
17212                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17213                         }
17214                         ndr->flags = _flags_save_string;
17215                 }
17216         }
17217         return NDR_ERR_SUCCESS;
17218 }
17219
17220 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17221 {
17222         uint32_t _ptr_port_name;
17223         TALLOC_CTX *_mem_save_port_name_0;
17224         if (ndr_flags & NDR_SCALARS) {
17225                 NDR_CHECK(ndr_pull_align(ndr, 5));
17226                 {
17227                         uint32_t _flags_save_string = ndr->flags;
17228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17229                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17230                         if (_ptr_port_name) {
17231                                 NDR_PULL_ALLOC(ndr, r->port_name);
17232                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17233                         } else {
17234                                 r->port_name = NULL;
17235                         }
17236                         ndr->flags = _flags_save_string;
17237                 }
17238                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17239                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17240         }
17241         if (ndr_flags & NDR_BUFFERS) {
17242                 {
17243                         uint32_t _flags_save_string = ndr->flags;
17244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17245                         if (r->port_name) {
17246                                 uint32_t _relative_save_offset;
17247                                 _relative_save_offset = ndr->offset;
17248                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17249                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17250                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17251                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17252                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17253                                 if (ndr->offset > ndr->relative_highest_offset) {
17254                                         ndr->relative_highest_offset = ndr->offset;
17255                                 }
17256                                 ndr->offset = _relative_save_offset;
17257                         }
17258                         ndr->flags = _flags_save_string;
17259                 }
17260         }
17261         return NDR_ERR_SUCCESS;
17262 }
17263
17264 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17265 {
17266         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17267         ndr->depth++;
17268         ndr_print_ptr(ndr, "port_name", r->port_name);
17269         ndr->depth++;
17270         if (r->port_name) {
17271                 ndr_print_string(ndr, "port_name", r->port_name);
17272         }
17273         ndr->depth--;
17274         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17275         ndr->depth--;
17276 }
17277
17278 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17279 {
17280         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17281 }
17282
17283 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17284 {
17285         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17286         if (ndr_flags & NDR_SCALARS) {
17287                 int level = ndr_push_get_switch_value(ndr, r);
17288                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17289                 switch (level) {
17290                         case 1: {
17291                                 NDR_CHECK(ndr_push_align(ndr, 5));
17292                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17293                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17294                         break; }
17295
17296                         case 2: {
17297                                 NDR_CHECK(ndr_push_align(ndr, 5));
17298                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17299                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17300                         break; }
17301
17302                         case 3: {
17303                                 NDR_CHECK(ndr_push_align(ndr, 5));
17304                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17305                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17306                         break; }
17307
17308                         case 0xff: {
17309                                 NDR_CHECK(ndr_push_align(ndr, 5));
17310                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17311                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17312                         break; }
17313
17314                         default: {
17315                         break; }
17316
17317                 }
17318         }
17319         if (ndr_flags & NDR_BUFFERS) {
17320                 int level = ndr_push_get_switch_value(ndr, r);
17321                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17322                 switch (level) {
17323                         case 1:
17324                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17325                         break;
17326
17327                         case 2:
17328                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17329                         break;
17330
17331                         case 3:
17332                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17333                         break;
17334
17335                         case 0xff:
17336                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17337                         break;
17338
17339                         default:
17340                         break;
17341
17342                 }
17343         }
17344         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17345         return NDR_ERR_SUCCESS;
17346 }
17347
17348 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17349 {
17350         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17351         int level;
17352         level = ndr_pull_get_switch_value(ndr, r);
17353         if (ndr_flags & NDR_SCALARS) {
17354                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17355                 switch (level) {
17356                         case 1: {
17357                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17358                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17359                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17360                         break; }
17361
17362                         case 2: {
17363                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17364                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17365                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17366                         break; }
17367
17368                         case 3: {
17369                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17370                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17371                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17372                         break; }
17373
17374                         case 0xff: {
17375                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17376                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17377                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17378                         break; }
17379
17380                         default: {
17381                         break; }
17382
17383                 }
17384         }
17385         if (ndr_flags & NDR_BUFFERS) {
17386                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17387                 switch (level) {
17388                         case 1:
17389                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17390                         break;
17391
17392                         case 2:
17393                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17394                         break;
17395
17396                         case 3:
17397                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17398                         break;
17399
17400                         case 0xff:
17401                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17402                         break;
17403
17404                         default:
17405                         break;
17406
17407                 }
17408         }
17409         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17410         return NDR_ERR_SUCCESS;
17411 }
17412
17413 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17414 {
17415         int level;
17416         level = ndr_print_get_switch_value(ndr, r);
17417         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17418         switch (level) {
17419                 case 1:
17420                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17421                 break;
17422
17423                 case 2:
17424                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17425                 break;
17426
17427                 case 3:
17428                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17429                 break;
17430
17431                 case 0xff:
17432                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17433                 break;
17434
17435                 default:
17436                 break;
17437
17438         }
17439 }
17440
17441 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17442 {
17443         if (ndr_flags & NDR_SCALARS) {
17444                 NDR_CHECK(ndr_push_align(ndr, 5));
17445                 {
17446                         uint32_t _flags_save_string = ndr->flags;
17447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17448                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17449                         ndr->flags = _flags_save_string;
17450                 }
17451                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17452         }
17453         if (ndr_flags & NDR_BUFFERS) {
17454                 {
17455                         uint32_t _flags_save_string = ndr->flags;
17456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17457                         if (r->monitor_name) {
17458                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17459                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17460                         }
17461                         ndr->flags = _flags_save_string;
17462                 }
17463         }
17464         return NDR_ERR_SUCCESS;
17465 }
17466
17467 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17468 {
17469         uint32_t _ptr_monitor_name;
17470         TALLOC_CTX *_mem_save_monitor_name_0;
17471         if (ndr_flags & NDR_SCALARS) {
17472                 NDR_CHECK(ndr_pull_align(ndr, 5));
17473                 {
17474                         uint32_t _flags_save_string = ndr->flags;
17475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17476                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17477                         if (_ptr_monitor_name) {
17478                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17479                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17480                         } else {
17481                                 r->monitor_name = NULL;
17482                         }
17483                         ndr->flags = _flags_save_string;
17484                 }
17485                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17486         }
17487         if (ndr_flags & NDR_BUFFERS) {
17488                 {
17489                         uint32_t _flags_save_string = ndr->flags;
17490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17491                         if (r->monitor_name) {
17492                                 uint32_t _relative_save_offset;
17493                                 _relative_save_offset = ndr->offset;
17494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17495                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17496                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17499                                 if (ndr->offset > ndr->relative_highest_offset) {
17500                                         ndr->relative_highest_offset = ndr->offset;
17501                                 }
17502                                 ndr->offset = _relative_save_offset;
17503                         }
17504                         ndr->flags = _flags_save_string;
17505                 }
17506         }
17507         return NDR_ERR_SUCCESS;
17508 }
17509
17510 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17511 {
17512         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17513         ndr->depth++;
17514         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17515         ndr->depth++;
17516         if (r->monitor_name) {
17517                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17518         }
17519         ndr->depth--;
17520         ndr->depth--;
17521 }
17522
17523 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17524 {
17525         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17526 }
17527
17528 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17529 {
17530         if (ndr_flags & NDR_SCALARS) {
17531                 NDR_CHECK(ndr_push_align(ndr, 5));
17532                 {
17533                         uint32_t _flags_save_string = ndr->flags;
17534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17536                         ndr->flags = _flags_save_string;
17537                 }
17538                 {
17539                         uint32_t _flags_save_string = ndr->flags;
17540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17541                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17542                         ndr->flags = _flags_save_string;
17543                 }
17544                 {
17545                         uint32_t _flags_save_string = ndr->flags;
17546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17548                         ndr->flags = _flags_save_string;
17549                 }
17550                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17551         }
17552         if (ndr_flags & NDR_BUFFERS) {
17553                 {
17554                         uint32_t _flags_save_string = ndr->flags;
17555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17556                         if (r->monitor_name) {
17557                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17558                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
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->environment) {
17566                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17567                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17568                         }
17569                         ndr->flags = _flags_save_string;
17570                 }
17571                 {
17572                         uint32_t _flags_save_string = ndr->flags;
17573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17574                         if (r->dll_name) {
17575                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17576                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17577                         }
17578                         ndr->flags = _flags_save_string;
17579                 }
17580         }
17581         return NDR_ERR_SUCCESS;
17582 }
17583
17584 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17585 {
17586         uint32_t _ptr_monitor_name;
17587         TALLOC_CTX *_mem_save_monitor_name_0;
17588         uint32_t _ptr_environment;
17589         TALLOC_CTX *_mem_save_environment_0;
17590         uint32_t _ptr_dll_name;
17591         TALLOC_CTX *_mem_save_dll_name_0;
17592         if (ndr_flags & NDR_SCALARS) {
17593                 NDR_CHECK(ndr_pull_align(ndr, 5));
17594                 {
17595                         uint32_t _flags_save_string = ndr->flags;
17596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17597                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17598                         if (_ptr_monitor_name) {
17599                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17600                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17601                         } else {
17602                                 r->monitor_name = NULL;
17603                         }
17604                         ndr->flags = _flags_save_string;
17605                 }
17606                 {
17607                         uint32_t _flags_save_string = ndr->flags;
17608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17609                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17610                         if (_ptr_environment) {
17611                                 NDR_PULL_ALLOC(ndr, r->environment);
17612                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17613                         } else {
17614                                 r->environment = NULL;
17615                         }
17616                         ndr->flags = _flags_save_string;
17617                 }
17618                 {
17619                         uint32_t _flags_save_string = ndr->flags;
17620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17621                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17622                         if (_ptr_dll_name) {
17623                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17624                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17625                         } else {
17626                                 r->dll_name = NULL;
17627                         }
17628                         ndr->flags = _flags_save_string;
17629                 }
17630                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17631         }
17632         if (ndr_flags & NDR_BUFFERS) {
17633                 {
17634                         uint32_t _flags_save_string = ndr->flags;
17635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17636                         if (r->monitor_name) {
17637                                 uint32_t _relative_save_offset;
17638                                 _relative_save_offset = ndr->offset;
17639                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17640                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17641                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17642                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17643                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17644                                 if (ndr->offset > ndr->relative_highest_offset) {
17645                                         ndr->relative_highest_offset = ndr->offset;
17646                                 }
17647                                 ndr->offset = _relative_save_offset;
17648                         }
17649                         ndr->flags = _flags_save_string;
17650                 }
17651                 {
17652                         uint32_t _flags_save_string = ndr->flags;
17653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17654                         if (r->environment) {
17655                                 uint32_t _relative_save_offset;
17656                                 _relative_save_offset = ndr->offset;
17657                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17658                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17659                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17660                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17661                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17662                                 if (ndr->offset > ndr->relative_highest_offset) {
17663                                         ndr->relative_highest_offset = ndr->offset;
17664                                 }
17665                                 ndr->offset = _relative_save_offset;
17666                         }
17667                         ndr->flags = _flags_save_string;
17668                 }
17669                 {
17670                         uint32_t _flags_save_string = ndr->flags;
17671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17672                         if (r->dll_name) {
17673                                 uint32_t _relative_save_offset;
17674                                 _relative_save_offset = ndr->offset;
17675                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17676                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17677                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17678                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17679                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17680                                 if (ndr->offset > ndr->relative_highest_offset) {
17681                                         ndr->relative_highest_offset = ndr->offset;
17682                                 }
17683                                 ndr->offset = _relative_save_offset;
17684                         }
17685                         ndr->flags = _flags_save_string;
17686                 }
17687         }
17688         return NDR_ERR_SUCCESS;
17689 }
17690
17691 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17692 {
17693         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17694         ndr->depth++;
17695         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17696         ndr->depth++;
17697         if (r->monitor_name) {
17698                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17699         }
17700         ndr->depth--;
17701         ndr_print_ptr(ndr, "environment", r->environment);
17702         ndr->depth++;
17703         if (r->environment) {
17704                 ndr_print_string(ndr, "environment", r->environment);
17705         }
17706         ndr->depth--;
17707         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17708         ndr->depth++;
17709         if (r->dll_name) {
17710                 ndr_print_string(ndr, "dll_name", r->dll_name);
17711         }
17712         ndr->depth--;
17713         ndr->depth--;
17714 }
17715
17716 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17717 {
17718         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17719 }
17720
17721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17722 {
17723         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17724         if (ndr_flags & NDR_SCALARS) {
17725                 int level = ndr_push_get_switch_value(ndr, r);
17726                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17727                 switch (level) {
17728                         case 1: {
17729                                 NDR_CHECK(ndr_push_align(ndr, 5));
17730                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17731                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17732                         break; }
17733
17734                         case 2: {
17735                                 NDR_CHECK(ndr_push_align(ndr, 5));
17736                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17737                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17738                         break; }
17739
17740                         default: {
17741                         break; }
17742
17743                 }
17744         }
17745         if (ndr_flags & NDR_BUFFERS) {
17746                 int level = ndr_push_get_switch_value(ndr, r);
17747                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17748                 switch (level) {
17749                         case 1:
17750                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17751                         break;
17752
17753                         case 2:
17754                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17755                         break;
17756
17757                         default:
17758                         break;
17759
17760                 }
17761         }
17762         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17763         return NDR_ERR_SUCCESS;
17764 }
17765
17766 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17767 {
17768         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17769         int level;
17770         level = ndr_pull_get_switch_value(ndr, r);
17771         if (ndr_flags & NDR_SCALARS) {
17772                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17773                 switch (level) {
17774                         case 1: {
17775                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17776                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17777                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17778                         break; }
17779
17780                         case 2: {
17781                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17782                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17783                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17784                         break; }
17785
17786                         default: {
17787                         break; }
17788
17789                 }
17790         }
17791         if (ndr_flags & NDR_BUFFERS) {
17792                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17793                 switch (level) {
17794                         case 1:
17795                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17796                         break;
17797
17798                         case 2:
17799                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17800                         break;
17801
17802                         default:
17803                         break;
17804
17805                 }
17806         }
17807         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17808         return NDR_ERR_SUCCESS;
17809 }
17810
17811 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17812 {
17813         int level;
17814         level = ndr_print_get_switch_value(ndr, r);
17815         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17816         switch (level) {
17817                 case 1:
17818                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17819                 break;
17820
17821                 case 2:
17822                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17823                 break;
17824
17825                 default:
17826                 break;
17827
17828         }
17829 }
17830
17831 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17832 {
17833         if (ndr_flags & NDR_SCALARS) {
17834                 NDR_CHECK(ndr_push_align(ndr, 5));
17835                 {
17836                         uint32_t _flags_save_string = ndr->flags;
17837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17838                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17839                         ndr->flags = _flags_save_string;
17840                 }
17841                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17842         }
17843         if (ndr_flags & NDR_BUFFERS) {
17844                 {
17845                         uint32_t _flags_save_string = ndr->flags;
17846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17847                         if (r->name_array) {
17848                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
17849                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17850                         }
17851                         ndr->flags = _flags_save_string;
17852                 }
17853         }
17854         return NDR_ERR_SUCCESS;
17855 }
17856
17857 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17858 {
17859         uint32_t _ptr_name_array;
17860         TALLOC_CTX *_mem_save_name_array_0;
17861         if (ndr_flags & NDR_SCALARS) {
17862                 NDR_CHECK(ndr_pull_align(ndr, 5));
17863                 {
17864                         uint32_t _flags_save_string = ndr->flags;
17865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17866                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17867                         if (_ptr_name_array) {
17868                                 NDR_PULL_ALLOC(ndr, r->name_array);
17869                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17870                         } else {
17871                                 r->name_array = NULL;
17872                         }
17873                         ndr->flags = _flags_save_string;
17874                 }
17875                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17876         }
17877         if (ndr_flags & NDR_BUFFERS) {
17878                 {
17879                         uint32_t _flags_save_string = ndr->flags;
17880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17881                         if (r->name_array) {
17882                                 uint32_t _relative_save_offset;
17883                                 _relative_save_offset = ndr->offset;
17884                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17885                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17886                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17887                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17888                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17889                                 if (ndr->offset > ndr->relative_highest_offset) {
17890                                         ndr->relative_highest_offset = ndr->offset;
17891                                 }
17892                                 ndr->offset = _relative_save_offset;
17893                         }
17894                         ndr->flags = _flags_save_string;
17895                 }
17896         }
17897         return NDR_ERR_SUCCESS;
17898 }
17899
17900 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17901 {
17902         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17903         ndr->depth++;
17904         ndr_print_ptr(ndr, "name_array", r->name_array);
17905         ndr->depth++;
17906         if (r->name_array) {
17907                 ndr_print_string(ndr, "name_array", r->name_array);
17908         }
17909         ndr->depth--;
17910         ndr->depth--;
17911 }
17912
17913 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17914 {
17915         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17916 }
17917
17918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17919 {
17920         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17921         if (ndr_flags & NDR_SCALARS) {
17922                 int level = ndr_push_get_switch_value(ndr, r);
17923                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17924                 switch (level) {
17925                         case 1: {
17926                                 NDR_CHECK(ndr_push_align(ndr, 5));
17927                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17928                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17929                         break; }
17930
17931                         default: {
17932                         break; }
17933
17934                 }
17935         }
17936         if (ndr_flags & NDR_BUFFERS) {
17937                 int level = ndr_push_get_switch_value(ndr, r);
17938                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17939                 switch (level) {
17940                         case 1:
17941                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17942                         break;
17943
17944                         default:
17945                         break;
17946
17947                 }
17948         }
17949         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17950         return NDR_ERR_SUCCESS;
17951 }
17952
17953 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17954 {
17955         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17956         int level;
17957         level = ndr_pull_get_switch_value(ndr, r);
17958         if (ndr_flags & NDR_SCALARS) {
17959                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17960                 switch (level) {
17961                         case 1: {
17962                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17963                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17964                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17965                         break; }
17966
17967                         default: {
17968                         break; }
17969
17970                 }
17971         }
17972         if (ndr_flags & NDR_BUFFERS) {
17973                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17974                 switch (level) {
17975                         case 1:
17976                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17977                         break;
17978
17979                         default:
17980                         break;
17981
17982                 }
17983         }
17984         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17985         return NDR_ERR_SUCCESS;
17986 }
17987
17988 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
17989 {
17990         int level;
17991         level = ndr_print_get_switch_value(ndr, r);
17992         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
17993         switch (level) {
17994                 case 1:
17995                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
17996                 break;
17997
17998                 default:
17999                 break;
18000
18001         }
18002 }
18003
18004 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18005 {
18006         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18007         return NDR_ERR_SUCCESS;
18008 }
18009
18010 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18011 {
18012         uint32_t v;
18013         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18014         *r = v;
18015         return NDR_ERR_SUCCESS;
18016 }
18017
18018 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18019 {
18020         ndr_print_uint32(ndr, name, r);
18021         ndr->depth++;
18022         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18023         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18024         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18025         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18026         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18027         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18028         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18029         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18030         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18031         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18032         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18033         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18034         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18035         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18036         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18037         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18038         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18039         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18043         ndr->depth--;
18044 }
18045
18046 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18047 {
18048         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18049         return NDR_ERR_SUCCESS;
18050 }
18051
18052 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18053 {
18054         uint16_t v;
18055         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18056         *r = v;
18057         return NDR_ERR_SUCCESS;
18058 }
18059
18060 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18061 {
18062         const char *val = NULL;
18063
18064         switch (r) {
18065                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18066                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18067                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18068                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18069                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18070                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18071                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18072                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18073                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18074                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18075                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18076                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18077                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18078                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18079                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18080                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18081                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18082                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18083                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18084                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18085                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18086                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18087                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18088                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18089         }
18090         ndr_print_enum(ndr, name, "ENUM", val, r);
18091 }
18092
18093 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18094 {
18095         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18096         return NDR_ERR_SUCCESS;
18097 }
18098
18099 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18100 {
18101         uint16_t v;
18102         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18103         *r = v;
18104         return NDR_ERR_SUCCESS;
18105 }
18106
18107 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18108 {
18109         const char *val = NULL;
18110
18111         switch (r) {
18112                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18113                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18114                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18115                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18116                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18117                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18118                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18119                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18120                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18121                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18122                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18123                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18124                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18125                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18126                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18127                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18128                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18129                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18130                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18131                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18132                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18133                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18134                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18135                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18136                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18137                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18138                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18139                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18140         }
18141         ndr_print_enum(ndr, name, "ENUM", val, r);
18142 }
18143
18144 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18145 {
18146         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18147         return NDR_ERR_SUCCESS;
18148 }
18149
18150 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18151 {
18152         uint16_t v;
18153         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18154         *r = v;
18155         return NDR_ERR_SUCCESS;
18156 }
18157
18158 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18159 {
18160         const char *val = NULL;
18161
18162         switch (r) {
18163                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18164                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18165         }
18166         ndr_print_enum(ndr, name, "ENUM", val, r);
18167 }
18168
18169 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18170 {
18171         if (ndr_flags & NDR_SCALARS) {
18172                 int level = ndr_push_get_switch_value(ndr, r);
18173                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18174                 switch (level) {
18175                         case PRINTER_NOTIFY_TYPE: {
18176                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18177                         break; }
18178
18179                         case JOB_NOTIFY_TYPE: {
18180                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18181                         break; }
18182
18183                         default: {
18184                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18185                         break; }
18186
18187                 }
18188         }
18189         if (ndr_flags & NDR_BUFFERS) {
18190                 int level = ndr_push_get_switch_value(ndr, r);
18191                 switch (level) {
18192                         case PRINTER_NOTIFY_TYPE:
18193                         break;
18194
18195                         case JOB_NOTIFY_TYPE:
18196                         break;
18197
18198                         default:
18199                         break;
18200
18201                 }
18202         }
18203         return NDR_ERR_SUCCESS;
18204 }
18205
18206 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18207 {
18208         int level;
18209         level = ndr_pull_get_switch_value(ndr, r);
18210         if (ndr_flags & NDR_SCALARS) {
18211                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18212                 switch (level) {
18213                         case PRINTER_NOTIFY_TYPE: {
18214                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18215                         break; }
18216
18217                         case JOB_NOTIFY_TYPE: {
18218                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18219                         break; }
18220
18221                         default: {
18222                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18223                         break; }
18224
18225                 }
18226         }
18227         if (ndr_flags & NDR_BUFFERS) {
18228                 switch (level) {
18229                         case PRINTER_NOTIFY_TYPE:
18230                         break;
18231
18232                         case JOB_NOTIFY_TYPE:
18233                         break;
18234
18235                         default:
18236                         break;
18237
18238                 }
18239         }
18240         return NDR_ERR_SUCCESS;
18241 }
18242
18243 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18244 {
18245         uint32_t cntr_fields_1;
18246         if (ndr_flags & NDR_SCALARS) {
18247                 NDR_CHECK(ndr_push_align(ndr, 5));
18248                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18249                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18254                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18255         }
18256         if (ndr_flags & NDR_BUFFERS) {
18257                 if (r->fields) {
18258                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18259                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18260                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18261                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18262                         }
18263                 }
18264         }
18265         return NDR_ERR_SUCCESS;
18266 }
18267
18268 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18269 {
18270         uint32_t _ptr_fields;
18271         uint32_t cntr_fields_1;
18272         TALLOC_CTX *_mem_save_fields_0;
18273         TALLOC_CTX *_mem_save_fields_1;
18274         if (ndr_flags & NDR_SCALARS) {
18275                 NDR_CHECK(ndr_pull_align(ndr, 5));
18276                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18277                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18282                 if (_ptr_fields) {
18283                         NDR_PULL_ALLOC(ndr, r->fields);
18284                 } else {
18285                         r->fields = NULL;
18286                 }
18287                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18288         }
18289         if (ndr_flags & NDR_BUFFERS) {
18290                 if (r->fields) {
18291                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18292                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18294                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18295                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18296                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18297                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18298                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18299                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18300                         }
18301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18303                 }
18304                 if (r->fields) {
18305                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18306                 }
18307         }
18308         return NDR_ERR_SUCCESS;
18309 }
18310
18311 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18312 {
18313         uint32_t cntr_fields_1;
18314         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18315         ndr->depth++;
18316         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18317         ndr_print_uint16(ndr, "u1", r->u1);
18318         ndr_print_uint32(ndr, "u2", r->u2);
18319         ndr_print_uint32(ndr, "u3", r->u3);
18320         ndr_print_uint32(ndr, "count", r->count);
18321         ndr_print_ptr(ndr, "fields", r->fields);
18322         ndr->depth++;
18323         if (r->fields) {
18324                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18325                 ndr->depth++;
18326                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18327                         char *idx_1=NULL;
18328                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18329                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18330                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18331                                 free(idx_1);
18332                         }
18333                 }
18334                 ndr->depth--;
18335         }
18336         ndr->depth--;
18337         ndr->depth--;
18338 }
18339
18340 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18341 {
18342         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18343         return NDR_ERR_SUCCESS;
18344 }
18345
18346 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18347 {
18348         uint32_t v;
18349         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18350         *r = v;
18351         return NDR_ERR_SUCCESS;
18352 }
18353
18354 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18355 {
18356         ndr_print_uint32(ndr, name, r);
18357         ndr->depth++;
18358         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18359         ndr->depth--;
18360 }
18361
18362 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18363 {
18364         uint32_t cntr_types_1;
18365         if (ndr_flags & NDR_SCALARS) {
18366                 NDR_CHECK(ndr_push_align(ndr, 5));
18367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18368                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18371                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18372         }
18373         if (ndr_flags & NDR_BUFFERS) {
18374                 if (r->types) {
18375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18376                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18377                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18378                         }
18379                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18380                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18381                         }
18382                 }
18383         }
18384         return NDR_ERR_SUCCESS;
18385 }
18386
18387 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18388 {
18389         uint32_t _ptr_types;
18390         uint32_t cntr_types_1;
18391         TALLOC_CTX *_mem_save_types_0;
18392         TALLOC_CTX *_mem_save_types_1;
18393         if (ndr_flags & NDR_SCALARS) {
18394                 NDR_CHECK(ndr_pull_align(ndr, 5));
18395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18396                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18399                 if (_ptr_types) {
18400                         NDR_PULL_ALLOC(ndr, r->types);
18401                 } else {
18402                         r->types = NULL;
18403                 }
18404                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18405         }
18406         if (ndr_flags & NDR_BUFFERS) {
18407                 if (r->types) {
18408                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18409                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18410                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18411                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18412                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18413                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18414                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18415                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18416                         }
18417                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18418                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18419                         }
18420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18422                 }
18423                 if (r->types) {
18424                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18425                 }
18426         }
18427         return NDR_ERR_SUCCESS;
18428 }
18429
18430 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18431 {
18432         uint32_t cntr_types_1;
18433         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18434         ndr->depth++;
18435         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18436         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18437         ndr_print_uint32(ndr, "count", r->count);
18438         ndr_print_ptr(ndr, "types", r->types);
18439         ndr->depth++;
18440         if (r->types) {
18441                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18442                 ndr->depth++;
18443                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18444                         char *idx_1=NULL;
18445                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18446                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18447                                 free(idx_1);
18448                         }
18449                 }
18450                 ndr->depth--;
18451         }
18452         ndr->depth--;
18453         ndr->depth--;
18454 }
18455
18456 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18457 {
18458         if (ndr_flags & NDR_SCALARS) {
18459                 NDR_CHECK(ndr_push_align(ndr, 5));
18460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18461                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18462                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18463         }
18464         if (ndr_flags & NDR_BUFFERS) {
18465                 if (r->string) {
18466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18468                 }
18469         }
18470         return NDR_ERR_SUCCESS;
18471 }
18472
18473 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18474 {
18475         uint32_t _ptr_string;
18476         TALLOC_CTX *_mem_save_string_0;
18477         if (ndr_flags & NDR_SCALARS) {
18478                 NDR_CHECK(ndr_pull_align(ndr, 5));
18479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18481                 if (_ptr_string) {
18482                         NDR_PULL_ALLOC(ndr, r->string);
18483                 } else {
18484                         r->string = NULL;
18485                 }
18486                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18487         }
18488         if (ndr_flags & NDR_BUFFERS) {
18489                 if (r->string) {
18490                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18491                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18492                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18493                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18495                 }
18496                 if (r->string) {
18497                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18498                 }
18499         }
18500         return NDR_ERR_SUCCESS;
18501 }
18502
18503 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18504 {
18505         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18506         ndr->depth++;
18507         ndr_print_uint32(ndr, "size", r->size);
18508         ndr_print_ptr(ndr, "string", r->string);
18509         ndr->depth++;
18510         if (r->string) {
18511                 ndr_print_string(ndr, "string", r->string);
18512         }
18513         ndr->depth--;
18514         ndr->depth--;
18515 }
18516
18517 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18518 {
18519         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18520         return NDR_ERR_SUCCESS;
18521 }
18522
18523 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18524 {
18525         uint32_t v;
18526         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18527         *r = v;
18528         return NDR_ERR_SUCCESS;
18529 }
18530
18531 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18532 {
18533         const char *val = NULL;
18534
18535         switch (r) {
18536                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18537                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18538                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18539                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18540                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18541         }
18542         ndr_print_enum(ndr, name, "ENUM", val, r);
18543 }
18544
18545 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18546 {
18547         if (ndr_flags & NDR_SCALARS) {
18548                 int level = ndr_push_get_switch_value(ndr, r);
18549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18550                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18551                 switch (level) {
18552                         case 1: {
18553                                 uint32_t cntr_integer_0;
18554                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18555                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18556                                 }
18557                         break; }
18558
18559                         case 2: {
18560                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18561                         break; }
18562
18563                         case 3: {
18564                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18565                         break; }
18566
18567                         case 4: {
18568                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18569                         break; }
18570
18571                         case 5: {
18572                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18573                         break; }
18574
18575                         default:
18576                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18577                 }
18578         }
18579         if (ndr_flags & NDR_BUFFERS) {
18580                 int level = ndr_push_get_switch_value(ndr, r);
18581                 switch (level) {
18582                         case 1:
18583                         break;
18584
18585                         case 2:
18586                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18587                         break;
18588
18589                         case 3:
18590                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18591                         break;
18592
18593                         case 4:
18594                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18595                         break;
18596
18597                         case 5:
18598                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18599                         break;
18600
18601                         default:
18602                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18603                 }
18604         }
18605         return NDR_ERR_SUCCESS;
18606 }
18607
18608 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18609 {
18610         int level;
18611         uint32_t _level;
18612         level = ndr_pull_get_switch_value(ndr, r);
18613         if (ndr_flags & NDR_SCALARS) {
18614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18615                 if (_level != level) {
18616                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18617                 }
18618                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18619                 switch (level) {
18620                         case 1: {
18621                                 uint32_t cntr_integer_0;
18622                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18623                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18624                                 }
18625                         break; }
18626
18627                         case 2: {
18628                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18629                         break; }
18630
18631                         case 3: {
18632                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18633                         break; }
18634
18635                         case 4: {
18636                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18637                         break; }
18638
18639                         case 5: {
18640                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18641                         break; }
18642
18643                         default:
18644                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18645                 }
18646         }
18647         if (ndr_flags & NDR_BUFFERS) {
18648                 switch (level) {
18649                         case 1:
18650                         break;
18651
18652                         case 2:
18653                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18654                         break;
18655
18656                         case 3:
18657                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18658                         break;
18659
18660                         case 4:
18661                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18662                         break;
18663
18664                         case 5:
18665                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18666                         break;
18667
18668                         default:
18669                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18670                 }
18671         }
18672         return NDR_ERR_SUCCESS;
18673 }
18674
18675 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18676 {
18677         int level;
18678         uint32_t cntr_integer_0;
18679         level = ndr_print_get_switch_value(ndr, r);
18680         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18681         switch (level) {
18682                 case 1:
18683                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18684                         ndr->depth++;
18685                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18686                                 char *idx_0=NULL;
18687                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18688                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18689                                         free(idx_0);
18690                                 }
18691                         }
18692                         ndr->depth--;
18693                 break;
18694
18695                 case 2:
18696                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18697                 break;
18698
18699                 case 3:
18700                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18701                 break;
18702
18703                 case 4:
18704                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18705                 break;
18706
18707                 case 5:
18708                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18709                 break;
18710
18711                 default:
18712                         ndr_print_bad_level(ndr, name, level);
18713         }
18714 }
18715
18716 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18717 {
18718         if (ndr_flags & NDR_SCALARS) {
18719                 NDR_CHECK(ndr_push_align(ndr, 5));
18720                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18721                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18722                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18723                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18725                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18726                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18727                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18728         }
18729         if (ndr_flags & NDR_BUFFERS) {
18730                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18731         }
18732         return NDR_ERR_SUCCESS;
18733 }
18734
18735 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18736 {
18737         if (ndr_flags & NDR_SCALARS) {
18738                 NDR_CHECK(ndr_pull_align(ndr, 5));
18739                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18740                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18741                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18742                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18744                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18745                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18746                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18747         }
18748         if (ndr_flags & NDR_BUFFERS) {
18749                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18750         }
18751         return NDR_ERR_SUCCESS;
18752 }
18753
18754 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18755 {
18756         ndr_print_struct(ndr, name, "spoolss_Notify");
18757         ndr->depth++;
18758         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18759         ndr_print_set_switch_value(ndr, &r->field, r->type);
18760         ndr_print_spoolss_Field(ndr, "field", &r->field);
18761         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18762         ndr_print_uint32(ndr, "job_id", r->job_id);
18763         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18764         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18765         ndr->depth--;
18766 }
18767
18768 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18769 {
18770         uint32_t cntr_notifies_0;
18771         if (ndr_flags & NDR_SCALARS) {
18772                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18773                 NDR_CHECK(ndr_push_align(ndr, 5));
18774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18777                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18778                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18779                 }
18780                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18781         }
18782         if (ndr_flags & NDR_BUFFERS) {
18783                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18784                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18785                 }
18786         }
18787         return NDR_ERR_SUCCESS;
18788 }
18789
18790 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18791 {
18792         uint32_t cntr_notifies_0;
18793         TALLOC_CTX *_mem_save_notifies_0;
18794         if (ndr_flags & NDR_SCALARS) {
18795                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18796                 NDR_CHECK(ndr_pull_align(ndr, 5));
18797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18800                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18801                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18802                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18803                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18804                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18805                 }
18806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18807                 if (r->notifies) {
18808                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18809                 }
18810                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18811         }
18812         if (ndr_flags & NDR_BUFFERS) {
18813                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18814                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18815                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18816                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18817                 }
18818                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18819         }
18820         return NDR_ERR_SUCCESS;
18821 }
18822
18823 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18824 {
18825         uint32_t cntr_notifies_0;
18826         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18827         ndr->depth++;
18828         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18829         ndr_print_uint32(ndr, "flags", r->flags);
18830         ndr_print_uint32(ndr, "count", r->count);
18831         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18832         ndr->depth++;
18833         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18834                 char *idx_0=NULL;
18835                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18836                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18837                         free(idx_0);
18838                 }
18839         }
18840         ndr->depth--;
18841         ndr->depth--;
18842 }
18843
18844 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18845 {
18846         if (ndr_flags & NDR_SCALARS) {
18847                 int level = ndr_push_get_switch_value(ndr, r);
18848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18849                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18850                 switch (level) {
18851                         case 0: {
18852                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18853                         break; }
18854
18855                         default:
18856                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18857                 }
18858         }
18859         if (ndr_flags & NDR_BUFFERS) {
18860                 int level = ndr_push_get_switch_value(ndr, r);
18861                 switch (level) {
18862                         case 0:
18863                                 if (r->info0) {
18864                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18865                                 }
18866                         break;
18867
18868                         default:
18869                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18870                 }
18871         }
18872         return NDR_ERR_SUCCESS;
18873 }
18874
18875 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18876 {
18877         int level;
18878         uint32_t _level;
18879         TALLOC_CTX *_mem_save_info0_0;
18880         level = ndr_pull_get_switch_value(ndr, r);
18881         if (ndr_flags & NDR_SCALARS) {
18882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18883                 if (_level != level) {
18884                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18885                 }
18886                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18887                 switch (level) {
18888                         case 0: {
18889                                 uint32_t _ptr_info0;
18890                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18891                                 if (_ptr_info0) {
18892                                         NDR_PULL_ALLOC(ndr, r->info0);
18893                                 } else {
18894                                         r->info0 = NULL;
18895                                 }
18896                         break; }
18897
18898                         default:
18899                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18900                 }
18901         }
18902         if (ndr_flags & NDR_BUFFERS) {
18903                 switch (level) {
18904                         case 0:
18905                                 if (r->info0) {
18906                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18907                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18908                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18909                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18910                                 }
18911                         break;
18912
18913                         default:
18914                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18915                 }
18916         }
18917         return NDR_ERR_SUCCESS;
18918 }
18919
18920 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18921 {
18922         int level;
18923         level = ndr_print_get_switch_value(ndr, r);
18924         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18925         switch (level) {
18926                 case 0:
18927                         ndr_print_ptr(ndr, "info0", r->info0);
18928                         ndr->depth++;
18929                         if (r->info0) {
18930                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18931                         }
18932                         ndr->depth--;
18933                 break;
18934
18935                 default:
18936                         ndr_print_bad_level(ndr, name, level);
18937         }
18938 }
18939
18940 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18941 {
18942         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18943         return NDR_ERR_SUCCESS;
18944 }
18945
18946 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18947 {
18948         uint32_t v;
18949         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18950         *r = v;
18951         return NDR_ERR_SUCCESS;
18952 }
18953
18954 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18955 {
18956         ndr_print_uint32(ndr, name, r);
18957         ndr->depth++;
18958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
18960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
18961         ndr->depth--;
18962 }
18963
18964 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
18965 {
18966         if (ndr_flags & NDR_SCALARS) {
18967                 NDR_CHECK(ndr_push_align(ndr, 5));
18968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18972                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18973                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18974                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18975                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18976         }
18977         if (ndr_flags & NDR_BUFFERS) {
18978                 if (r->client) {
18979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18980                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18981                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18982                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18983                 }
18984                 if (r->user) {
18985                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18986                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18988                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18989                 }
18990         }
18991         return NDR_ERR_SUCCESS;
18992 }
18993
18994 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
18995 {
18996         uint32_t _ptr_client;
18997         TALLOC_CTX *_mem_save_client_0;
18998         uint32_t _ptr_user;
18999         TALLOC_CTX *_mem_save_user_0;
19000         if (ndr_flags & NDR_SCALARS) {
19001                 NDR_CHECK(ndr_pull_align(ndr, 5));
19002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19004                 if (_ptr_client) {
19005                         NDR_PULL_ALLOC(ndr, r->client);
19006                 } else {
19007                         r->client = NULL;
19008                 }
19009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19010                 if (_ptr_user) {
19011                         NDR_PULL_ALLOC(ndr, r->user);
19012                 } else {
19013                         r->user = NULL;
19014                 }
19015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19016                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19017                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19018                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19019                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19020         }
19021         if (ndr_flags & NDR_BUFFERS) {
19022                 if (r->client) {
19023                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19024                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19026                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19027                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19028                                 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));
19029                         }
19030                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19031                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19033                 }
19034                 if (r->user) {
19035                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19036                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19039                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19040                                 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));
19041                         }
19042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19045                 }
19046         }
19047         return NDR_ERR_SUCCESS;
19048 }
19049
19050 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19051 {
19052         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19053         ndr->depth++;
19054         ndr_print_uint32(ndr, "size", r->size);
19055         ndr_print_ptr(ndr, "client", r->client);
19056         ndr->depth++;
19057         if (r->client) {
19058                 ndr_print_string(ndr, "client", r->client);
19059         }
19060         ndr->depth--;
19061         ndr_print_ptr(ndr, "user", r->user);
19062         ndr->depth++;
19063         if (r->user) {
19064                 ndr_print_string(ndr, "user", r->user);
19065         }
19066         ndr->depth--;
19067         ndr_print_uint32(ndr, "build", r->build);
19068         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19069         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19070         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19071         ndr->depth--;
19072 }
19073
19074 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19075 {
19076         if (ndr_flags & NDR_SCALARS) {
19077                 NDR_CHECK(ndr_push_align(ndr, 4));
19078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19079                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19080         }
19081         if (ndr_flags & NDR_BUFFERS) {
19082         }
19083         return NDR_ERR_SUCCESS;
19084 }
19085
19086 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19087 {
19088         if (ndr_flags & NDR_SCALARS) {
19089                 NDR_CHECK(ndr_pull_align(ndr, 4));
19090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19091                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19092         }
19093         if (ndr_flags & NDR_BUFFERS) {
19094         }
19095         return NDR_ERR_SUCCESS;
19096 }
19097
19098 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19099 {
19100         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19101         ndr->depth++;
19102         ndr_print_uint32(ndr, "not_used", r->not_used);
19103         ndr->depth--;
19104 }
19105
19106 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19107 {
19108         if (ndr_flags & NDR_SCALARS) {
19109                 NDR_CHECK(ndr_push_align(ndr, 5));
19110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19113                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19116                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19117                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19118                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19119                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19120                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19121         }
19122         if (ndr_flags & NDR_BUFFERS) {
19123                 if (r->client) {
19124                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19127                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19128                 }
19129                 if (r->user) {
19130                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19133                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19134                 }
19135         }
19136         return NDR_ERR_SUCCESS;
19137 }
19138
19139 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19140 {
19141         uint32_t _ptr_client;
19142         TALLOC_CTX *_mem_save_client_0;
19143         uint32_t _ptr_user;
19144         TALLOC_CTX *_mem_save_user_0;
19145         if (ndr_flags & NDR_SCALARS) {
19146                 NDR_CHECK(ndr_pull_align(ndr, 5));
19147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19150                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19151                 if (_ptr_client) {
19152                         NDR_PULL_ALLOC(ndr, r->client);
19153                 } else {
19154                         r->client = NULL;
19155                 }
19156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19157                 if (_ptr_user) {
19158                         NDR_PULL_ALLOC(ndr, r->user);
19159                 } else {
19160                         r->user = NULL;
19161                 }
19162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19163                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19164                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19165                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19166                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19167                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19168         }
19169         if (ndr_flags & NDR_BUFFERS) {
19170                 if (r->client) {
19171                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19172                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19175                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19176                                 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));
19177                         }
19178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19181                 }
19182                 if (r->user) {
19183                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19184                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19187                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19188                                 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));
19189                         }
19190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19193                 }
19194         }
19195         return NDR_ERR_SUCCESS;
19196 }
19197
19198 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19199 {
19200         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19201         ndr->depth++;
19202         ndr_print_uint32(ndr, "size", r->size);
19203         ndr_print_uint32(ndr, "flags", r->flags);
19204         ndr_print_uint32(ndr, "size2", r->size2);
19205         ndr_print_ptr(ndr, "client", r->client);
19206         ndr->depth++;
19207         if (r->client) {
19208                 ndr_print_string(ndr, "client", r->client);
19209         }
19210         ndr->depth--;
19211         ndr_print_ptr(ndr, "user", r->user);
19212         ndr->depth++;
19213         if (r->user) {
19214                 ndr_print_string(ndr, "user", r->user);
19215         }
19216         ndr->depth--;
19217         ndr_print_uint32(ndr, "build", r->build);
19218         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19219         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19220         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19221         ndr_print_udlong(ndr, "reserved", r->reserved);
19222         ndr->depth--;
19223 }
19224
19225 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19226 {
19227         if (ndr_flags & NDR_SCALARS) {
19228                 int level = ndr_push_get_switch_value(ndr, r);
19229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19230                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19231                 switch (level) {
19232                         case 1: {
19233                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19234                         break; }
19235
19236                         case 2: {
19237                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19238                         break; }
19239
19240                         case 3: {
19241                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19242                         break; }
19243
19244                         default:
19245                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19246                 }
19247         }
19248         if (ndr_flags & NDR_BUFFERS) {
19249                 int level = ndr_push_get_switch_value(ndr, r);
19250                 switch (level) {
19251                         case 1:
19252                                 if (r->level1) {
19253                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19254                                 }
19255                         break;
19256
19257                         case 2:
19258                                 if (r->level2) {
19259                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19260                                 }
19261                         break;
19262
19263                         case 3:
19264                                 if (r->level3) {
19265                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19266                                 }
19267                         break;
19268
19269                         default:
19270                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19271                 }
19272         }
19273         return NDR_ERR_SUCCESS;
19274 }
19275
19276 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19277 {
19278         int level;
19279         uint32_t _level;
19280         TALLOC_CTX *_mem_save_level1_0;
19281         TALLOC_CTX *_mem_save_level2_0;
19282         TALLOC_CTX *_mem_save_level3_0;
19283         level = ndr_pull_get_switch_value(ndr, r);
19284         if (ndr_flags & NDR_SCALARS) {
19285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19286                 if (_level != level) {
19287                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19288                 }
19289                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19290                 switch (level) {
19291                         case 1: {
19292                                 uint32_t _ptr_level1;
19293                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19294                                 if (_ptr_level1) {
19295                                         NDR_PULL_ALLOC(ndr, r->level1);
19296                                 } else {
19297                                         r->level1 = NULL;
19298                                 }
19299                         break; }
19300
19301                         case 2: {
19302                                 uint32_t _ptr_level2;
19303                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19304                                 if (_ptr_level2) {
19305                                         NDR_PULL_ALLOC(ndr, r->level2);
19306                                 } else {
19307                                         r->level2 = NULL;
19308                                 }
19309                         break; }
19310
19311                         case 3: {
19312                                 uint32_t _ptr_level3;
19313                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19314                                 if (_ptr_level3) {
19315                                         NDR_PULL_ALLOC(ndr, r->level3);
19316                                 } else {
19317                                         r->level3 = NULL;
19318                                 }
19319                         break; }
19320
19321                         default:
19322                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19323                 }
19324         }
19325         if (ndr_flags & NDR_BUFFERS) {
19326                 switch (level) {
19327                         case 1:
19328                                 if (r->level1) {
19329                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19330                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19331                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19332                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19333                                 }
19334                         break;
19335
19336                         case 2:
19337                                 if (r->level2) {
19338                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19339                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19340                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19341                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19342                                 }
19343                         break;
19344
19345                         case 3:
19346                                 if (r->level3) {
19347                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19348                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19349                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19350                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19351                                 }
19352                         break;
19353
19354                         default:
19355                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19356                 }
19357         }
19358         return NDR_ERR_SUCCESS;
19359 }
19360
19361 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19362 {
19363         int level;
19364         level = ndr_print_get_switch_value(ndr, r);
19365         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19366         switch (level) {
19367                 case 1:
19368                         ndr_print_ptr(ndr, "level1", r->level1);
19369                         ndr->depth++;
19370                         if (r->level1) {
19371                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19372                         }
19373                         ndr->depth--;
19374                 break;
19375
19376                 case 2:
19377                         ndr_print_ptr(ndr, "level2", r->level2);
19378                         ndr->depth++;
19379                         if (r->level2) {
19380                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19381                         }
19382                         ndr->depth--;
19383                 break;
19384
19385                 case 3:
19386                         ndr_print_ptr(ndr, "level3", r->level3);
19387                         ndr->depth++;
19388                         if (r->level3) {
19389                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19390                         }
19391                         ndr->depth--;
19392                 break;
19393
19394                 default:
19395                         ndr_print_bad_level(ndr, name, level);
19396         }
19397 }
19398
19399 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19400 {
19401         if (ndr_flags & NDR_SCALARS) {
19402                 NDR_CHECK(ndr_push_align(ndr, 5));
19403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19404                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19405                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19406                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19407         }
19408         if (ndr_flags & NDR_BUFFERS) {
19409                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19410         }
19411         return NDR_ERR_SUCCESS;
19412 }
19413
19414 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19415 {
19416         if (ndr_flags & NDR_SCALARS) {
19417                 NDR_CHECK(ndr_pull_align(ndr, 5));
19418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19419                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19420                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19421                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19422         }
19423         if (ndr_flags & NDR_BUFFERS) {
19424                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19425         }
19426         return NDR_ERR_SUCCESS;
19427 }
19428
19429 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19430 {
19431         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19432         ndr->depth++;
19433         ndr_print_uint32(ndr, "level", r->level);
19434         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19435         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19436         ndr->depth--;
19437 }
19438
19439 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19440 {
19441         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19442         return NDR_ERR_SUCCESS;
19443 }
19444
19445 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19446 {
19447         uint32_t v;
19448         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19449         *r = v;
19450         return NDR_ERR_SUCCESS;
19451 }
19452
19453 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19454 {
19455         ndr_print_uint32(ndr, name, r);
19456         ndr->depth++;
19457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19463         ndr->depth--;
19464 }
19465
19466 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19467 {
19468         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19469         if (ndr_flags & NDR_SCALARS) {
19470                 NDR_CHECK(ndr_push_align(ndr, 5));
19471                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19472                 {
19473                         uint32_t _flags_save_string = ndr->flags;
19474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19475                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19476                         ndr->flags = _flags_save_string;
19477                 }
19478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19479                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19480                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19482                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19483         }
19484         if (ndr_flags & NDR_BUFFERS) {
19485                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19486                 {
19487                         uint32_t _flags_save_string = ndr->flags;
19488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19489                         if (r->value_name) {
19490                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
19491                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19492                         }
19493                         ndr->flags = _flags_save_string;
19494                 }
19495                 if (r->data) {
19496                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
19497                         {
19498                                 struct ndr_push *_ndr_data;
19499                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19500                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19501                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19502                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19503                         }
19504                 }
19505         }
19506         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19507         return NDR_ERR_SUCCESS;
19508 }
19509
19510 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19511 {
19512         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19513         uint32_t _ptr_value_name;
19514         TALLOC_CTX *_mem_save_value_name_0;
19515         uint32_t _ptr_data;
19516         TALLOC_CTX *_mem_save_data_0;
19517         if (ndr_flags & NDR_SCALARS) {
19518                 NDR_CHECK(ndr_pull_align(ndr, 5));
19519                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19520                 {
19521                         uint32_t _flags_save_string = ndr->flags;
19522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19524                         if (_ptr_value_name) {
19525                                 NDR_PULL_ALLOC(ndr, r->value_name);
19526                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19527                         } else {
19528                                 r->value_name = NULL;
19529                         }
19530                         ndr->flags = _flags_save_string;
19531                 }
19532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19533                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19535                 if (_ptr_data) {
19536                         NDR_PULL_ALLOC(ndr, r->data);
19537                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19538                 } else {
19539                         r->data = NULL;
19540                 }
19541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19542                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19543         }
19544         if (ndr_flags & NDR_BUFFERS) {
19545                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19546                 {
19547                         uint32_t _flags_save_string = ndr->flags;
19548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19549                         if (r->value_name) {
19550                                 uint32_t _relative_save_offset;
19551                                 _relative_save_offset = ndr->offset;
19552                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19553                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19554                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19555                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19556                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19557                                 if (ndr->offset > ndr->relative_highest_offset) {
19558                                         ndr->relative_highest_offset = ndr->offset;
19559                                 }
19560                                 ndr->offset = _relative_save_offset;
19561                         }
19562                         ndr->flags = _flags_save_string;
19563                 }
19564                 if (r->data) {
19565                         uint32_t _relative_save_offset;
19566                         _relative_save_offset = ndr->offset;
19567                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19568                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19569                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19570                         {
19571                                 struct ndr_pull *_ndr_data;
19572                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19573                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19574                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19575                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19576                         }
19577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19578                         if (ndr->offset > ndr->relative_highest_offset) {
19579                                 ndr->relative_highest_offset = ndr->offset;
19580                         }
19581                         ndr->offset = _relative_save_offset;
19582                 }
19583         }
19584         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19585         return NDR_ERR_SUCCESS;
19586 }
19587
19588 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19589 {
19590         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19591         ndr->depth++;
19592         ndr_print_ptr(ndr, "value_name", r->value_name);
19593         ndr->depth++;
19594         if (r->value_name) {
19595                 ndr_print_string(ndr, "value_name", r->value_name);
19596         }
19597         ndr->depth--;
19598         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19599         ndr_print_winreg_Type(ndr, "type", r->type);
19600         ndr_print_ptr(ndr, "data", r->data);
19601         ndr->depth++;
19602         if (r->data) {
19603                 ndr_print_set_switch_value(ndr, r->data, r->type);
19604                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19605         }
19606         ndr->depth--;
19607         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);
19608         ndr->depth--;
19609 }
19610
19611 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19612 {
19613         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19614 }
19615
19616 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19617 {
19618         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19619         return NDR_ERR_SUCCESS;
19620 }
19621
19622 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19623 {
19624         uint32_t v;
19625         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19626         *r = v;
19627         return NDR_ERR_SUCCESS;
19628 }
19629
19630 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19631 {
19632         ndr_print_uint32(ndr, name, r);
19633         ndr->depth++;
19634         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19635         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19636         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19637         ndr->depth--;
19638 }
19639
19640 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19641 {
19642         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19643         return NDR_ERR_SUCCESS;
19644 }
19645
19646 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19647 {
19648         uint32_t v;
19649         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19650         *r = v;
19651         return NDR_ERR_SUCCESS;
19652 }
19653
19654 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19655 {
19656         const char *val = NULL;
19657
19658         switch (r) {
19659                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19660                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19661         }
19662         ndr_print_enum(ndr, name, "ENUM", val, r);
19663 }
19664
19665 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19666 {
19667         if (ndr_flags & NDR_SCALARS) {
19668                 NDR_CHECK(ndr_push_align(ndr, 4));
19669                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19671                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19674                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19675                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19677                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19678                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19679                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19680                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19684                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19685         }
19686         if (ndr_flags & NDR_BUFFERS) {
19687         }
19688         return NDR_ERR_SUCCESS;
19689 }
19690
19691 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19692 {
19693         if (ndr_flags & NDR_SCALARS) {
19694                 NDR_CHECK(ndr_pull_align(ndr, 4));
19695                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19697                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19700                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19701                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19703                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19704                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19705                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19706                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19708                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19710                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19711         }
19712         if (ndr_flags & NDR_BUFFERS) {
19713         }
19714         return NDR_ERR_SUCCESS;
19715 }
19716
19717 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19718 {
19719         ndr_print_struct(ndr, name, "spoolss_PortData1");
19720         ndr->depth++;
19721         ndr_print_string(ndr, "portname", r->portname);
19722         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19723         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19724         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19725         ndr_print_uint32(ndr, "reserved", r->reserved);
19726         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19727         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19728         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19729         ndr_print_string(ndr, "queue", r->queue);
19730         ndr_print_string(ndr, "ip_address", r->ip_address);
19731         ndr_print_string(ndr, "hardware_address", r->hardware_address);
19732         ndr_print_string(ndr, "device_type", r->device_type);
19733         ndr_print_uint32(ndr, "port_number", r->port_number);
19734         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19735         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19736         ndr->depth--;
19737 }
19738
19739 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19740 {
19741         if (ndr_flags & NDR_SCALARS) {
19742                 NDR_CHECK(ndr_push_align(ndr, 4));
19743                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19745                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19748                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19749                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19751                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19752                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19757                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19758         }
19759         if (ndr_flags & NDR_BUFFERS) {
19760         }
19761         return NDR_ERR_SUCCESS;
19762 }
19763
19764 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19765 {
19766         if (ndr_flags & NDR_SCALARS) {
19767                 NDR_CHECK(ndr_pull_align(ndr, 4));
19768                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19770                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19773                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19774                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19776                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19777                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19782                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19783         }
19784         if (ndr_flags & NDR_BUFFERS) {
19785         }
19786         return NDR_ERR_SUCCESS;
19787 }
19788
19789 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19790 {
19791         ndr_print_struct(ndr, name, "spoolss_PortData2");
19792         ndr->depth++;
19793         ndr_print_string(ndr, "portname", r->portname);
19794         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19795         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19796         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19797         ndr_print_uint32(ndr, "reserved", r->reserved);
19798         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19799         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19800         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19801         ndr_print_string(ndr, "queue", r->queue);
19802         ndr_print_string(ndr, "device_type", r->device_type);
19803         ndr_print_uint32(ndr, "port_number", r->port_number);
19804         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19805         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19806         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19807         ndr->depth--;
19808 }
19809
19810 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19811 {
19812         if (ndr_flags & NDR_SCALARS) {
19813                 NDR_CHECK(ndr_push_align(ndr, 4));
19814                 {
19815                         uint32_t _flags_save_string = ndr->flags;
19816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19817                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19818                         ndr->flags = _flags_save_string;
19819                 }
19820                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19821         }
19822         if (ndr_flags & NDR_BUFFERS) {
19823         }
19824         return NDR_ERR_SUCCESS;
19825 }
19826
19827 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19828 {
19829         if (ndr_flags & NDR_SCALARS) {
19830                 NDR_CHECK(ndr_pull_align(ndr, 4));
19831                 {
19832                         uint32_t _flags_save_string = ndr->flags;
19833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19834                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19835                         ndr->flags = _flags_save_string;
19836                 }
19837                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19838         }
19839         if (ndr_flags & NDR_BUFFERS) {
19840         }
19841         return NDR_ERR_SUCCESS;
19842 }
19843
19844 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19845 {
19846         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19847         ndr->depth++;
19848         ndr_print_string(ndr, "dll_name", r->dll_name);
19849         ndr->depth--;
19850 }
19851
19852 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19853 {
19854         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19855         return NDR_ERR_SUCCESS;
19856 }
19857
19858 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19859 {
19860         uint32_t v;
19861         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19862         *r = v;
19863         return NDR_ERR_SUCCESS;
19864 }
19865
19866 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19867 {
19868         ndr_print_uint32(ndr, name, r);
19869         ndr->depth++;
19870         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
19871         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
19872         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
19873         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
19874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
19875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
19876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
19877         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
19878         ndr->depth--;
19879 }
19880
19881 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
19882 {
19883         if (ndr_flags & NDR_SCALARS) {
19884                 NDR_CHECK(ndr_push_align(ndr, 8));
19885                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19886                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
19887                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
19888                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
19889                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
19890         }
19891         if (ndr_flags & NDR_BUFFERS) {
19892         }
19893         return NDR_ERR_SUCCESS;
19894 }
19895
19896 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
19897 {
19898         if (ndr_flags & NDR_SCALARS) {
19899                 NDR_CHECK(ndr_pull_align(ndr, 8));
19900                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19901                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
19902                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
19903                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
19904                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
19905         }
19906         if (ndr_flags & NDR_BUFFERS) {
19907         }
19908         return NDR_ERR_SUCCESS;
19909 }
19910
19911 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
19912 {
19913         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
19914         ndr->depth++;
19915         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
19916         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
19917         ndr_print_hyper(ndr, "driver_version", r->driver_version);
19918         ndr_print_string(ndr, "formname", r->formname);
19919         ndr->depth--;
19920 }
19921
19922 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
19923 {
19924         if (flags & NDR_IN) {
19925                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
19926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19927                 if (r->in.server) {
19928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19931                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19932                 }
19933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19934                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19935                 if (r->in.buffer) {
19936                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19937                 }
19938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19939         }
19940         if (flags & NDR_OUT) {
19941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19942                 if (r->out.info) {
19943                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19944                 }
19945                 if (r->out.needed == NULL) {
19946                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19947                 }
19948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19949                 if (r->out.count == NULL) {
19950                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19951                 }
19952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19953                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19954         }
19955         return NDR_ERR_SUCCESS;
19956 }
19957
19958 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
19959 {
19960         uint32_t _ptr_server;
19961         uint32_t _ptr_buffer;
19962         uint32_t _ptr_info;
19963         TALLOC_CTX *_mem_save_server_0;
19964         TALLOC_CTX *_mem_save_buffer_0;
19965         TALLOC_CTX *_mem_save_info_0;
19966         TALLOC_CTX *_mem_save_needed_0;
19967         TALLOC_CTX *_mem_save_count_0;
19968         if (flags & NDR_IN) {
19969                 ZERO_STRUCT(r->out);
19970
19971                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
19972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19973                 if (_ptr_server) {
19974                         NDR_PULL_ALLOC(ndr, r->in.server);
19975                 } else {
19976                         r->in.server = NULL;
19977                 }
19978                 if (r->in.server) {
19979                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19980                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19981                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19982                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19983                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19984                                 return 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));
19985                         }
19986                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19987                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19989                 }
19990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19991                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19992                 if (_ptr_buffer) {
19993                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19994                 } else {
19995                         r->in.buffer = NULL;
19996                 }
19997                 if (r->in.buffer) {
19998                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19999                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20000                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20002                 }
20003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20004                 NDR_PULL_ALLOC(ndr, r->out.needed);
20005                 ZERO_STRUCTP(r->out.needed);
20006                 NDR_PULL_ALLOC(ndr, r->out.count);
20007                 ZERO_STRUCTP(r->out.count);
20008         }
20009         if (flags & NDR_OUT) {
20010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20011                 if (_ptr_info) {
20012                         NDR_PULL_ALLOC(ndr, r->out.info);
20013                 } else {
20014                         r->out.info = NULL;
20015                 }
20016                 if (r->out.info) {
20017                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20018                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20019                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20021                 }
20022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20023                         NDR_PULL_ALLOC(ndr, r->out.needed);
20024                 }
20025                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20026                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20030                         NDR_PULL_ALLOC(ndr, r->out.count);
20031                 }
20032                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20033                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20036                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20037         }
20038         return NDR_ERR_SUCCESS;
20039 }
20040
20041 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20042 {
20043         uint32_t cntr_info_0;
20044         if (flags & NDR_IN) {
20045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20047         }
20048         if (flags & NDR_OUT) {
20049                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20050                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20051                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20052                 }
20053                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20054                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20055                 }
20056         }
20057         return NDR_ERR_SUCCESS;
20058 }
20059
20060 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20061 {
20062         uint32_t cntr_info_0;
20063         TALLOC_CTX *_mem_save_info_0;
20064         if (flags & NDR_IN) {
20065                 ZERO_STRUCT(r->out);
20066
20067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20069         }
20070         if (flags & NDR_OUT) {
20071                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20072                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20073                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20074                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20075                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20076                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20077                 }
20078                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20079                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20080                 }
20081                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20082         }
20083         return NDR_ERR_SUCCESS;
20084 }
20085
20086 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20087 {
20088         uint32_t cntr_info_2;
20089         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20090         ndr->depth++;
20091         if (flags & NDR_SET_VALUES) {
20092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20093         }
20094         if (flags & NDR_IN) {
20095                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20096                 ndr->depth++;
20097                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20098                 ndr_print_ptr(ndr, "server", r->in.server);
20099                 ndr->depth++;
20100                 if (r->in.server) {
20101                         ndr_print_string(ndr, "server", r->in.server);
20102                 }
20103                 ndr->depth--;
20104                 ndr_print_uint32(ndr, "level", r->in.level);
20105                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20106                 ndr->depth++;
20107                 if (r->in.buffer) {
20108                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20109                 }
20110                 ndr->depth--;
20111                 ndr_print_uint32(ndr, "offered", r->in.offered);
20112                 ndr->depth--;
20113         }
20114         if (flags & NDR_OUT) {
20115                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20116                 ndr->depth++;
20117                 ndr_print_ptr(ndr, "count", r->out.count);
20118                 ndr->depth++;
20119                 ndr_print_uint32(ndr, "count", *r->out.count);
20120                 ndr->depth--;
20121                 ndr_print_ptr(ndr, "info", r->out.info);
20122                 ndr->depth++;
20123                 ndr_print_ptr(ndr, "info", *r->out.info);
20124                 ndr->depth++;
20125                 if (*r->out.info) {
20126                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20127                         ndr->depth++;
20128                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20129                                 char *idx_2=NULL;
20130                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20131                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20132                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20133                                         free(idx_2);
20134                                 }
20135                         }
20136                         ndr->depth--;
20137                 }
20138                 ndr->depth--;
20139                 ndr->depth--;
20140                 ndr_print_ptr(ndr, "needed", r->out.needed);
20141                 ndr->depth++;
20142                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20143                 ndr->depth--;
20144                 ndr_print_WERROR(ndr, "result", r->out.result);
20145                 ndr->depth--;
20146         }
20147         ndr->depth--;
20148 }
20149
20150 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20151 {
20152         if (flags & NDR_IN) {
20153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20154                 if (r->in.printername) {
20155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20158                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20159                 }
20160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20161                 if (r->in.datatype) {
20162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20164                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20165                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20166                 }
20167                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20168                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20169         }
20170         if (flags & NDR_OUT) {
20171                 if (r->out.handle == NULL) {
20172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20173                 }
20174                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20175                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20176         }
20177         return NDR_ERR_SUCCESS;
20178 }
20179
20180 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20181 {
20182         uint32_t _ptr_printername;
20183         uint32_t _ptr_datatype;
20184         TALLOC_CTX *_mem_save_printername_0;
20185         TALLOC_CTX *_mem_save_datatype_0;
20186         TALLOC_CTX *_mem_save_handle_0;
20187         if (flags & NDR_IN) {
20188                 ZERO_STRUCT(r->out);
20189
20190                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20191                 if (_ptr_printername) {
20192                         NDR_PULL_ALLOC(ndr, r->in.printername);
20193                 } else {
20194                         r->in.printername = NULL;
20195                 }
20196                 if (r->in.printername) {
20197                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20198                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20201                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20202                                 return 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));
20203                         }
20204                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20207                 }
20208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20209                 if (_ptr_datatype) {
20210                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20211                 } else {
20212                         r->in.datatype = NULL;
20213                 }
20214                 if (r->in.datatype) {
20215                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20216                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20218                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20219                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20220                                 return 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));
20221                         }
20222                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20223                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20225                 }
20226                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20227                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20228                 NDR_PULL_ALLOC(ndr, r->out.handle);
20229                 ZERO_STRUCTP(r->out.handle);
20230         }
20231         if (flags & NDR_OUT) {
20232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20233                         NDR_PULL_ALLOC(ndr, r->out.handle);
20234                 }
20235                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20236                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20237                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20239                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20240         }
20241         return NDR_ERR_SUCCESS;
20242 }
20243
20244 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20245 {
20246         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20247         ndr->depth++;
20248         if (flags & NDR_SET_VALUES) {
20249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20250         }
20251         if (flags & NDR_IN) {
20252                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20253                 ndr->depth++;
20254                 ndr_print_ptr(ndr, "printername", r->in.printername);
20255                 ndr->depth++;
20256                 if (r->in.printername) {
20257                         ndr_print_string(ndr, "printername", r->in.printername);
20258                 }
20259                 ndr->depth--;
20260                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20261                 ndr->depth++;
20262                 if (r->in.datatype) {
20263                         ndr_print_string(ndr, "datatype", r->in.datatype);
20264                 }
20265                 ndr->depth--;
20266                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20267                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20268                 ndr->depth--;
20269         }
20270         if (flags & NDR_OUT) {
20271                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20272                 ndr->depth++;
20273                 ndr_print_ptr(ndr, "handle", r->out.handle);
20274                 ndr->depth++;
20275                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20276                 ndr->depth--;
20277                 ndr_print_WERROR(ndr, "result", r->out.result);
20278                 ndr->depth--;
20279         }
20280         ndr->depth--;
20281 }
20282
20283 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20284 {
20285         if (flags & NDR_IN) {
20286                 if (r->in.handle == NULL) {
20287                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20288                 }
20289                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20291                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20292                 if (r->in.ctr) {
20293                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20294                 }
20295                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20296         }
20297         if (flags & NDR_OUT) {
20298                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20299         }
20300         return NDR_ERR_SUCCESS;
20301 }
20302
20303 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20304 {
20305         uint32_t _ptr_ctr;
20306         TALLOC_CTX *_mem_save_handle_0;
20307         TALLOC_CTX *_mem_save_ctr_0;
20308         if (flags & NDR_IN) {
20309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20310                         NDR_PULL_ALLOC(ndr, r->in.handle);
20311                 }
20312                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20313                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20314                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20318                 if (_ptr_ctr) {
20319                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20320                 } else {
20321                         r->in.ctr = NULL;
20322                 }
20323                 if (r->in.ctr) {
20324                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20325                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20326                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20328                 }
20329                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20330         }
20331         if (flags & NDR_OUT) {
20332                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20333         }
20334         return NDR_ERR_SUCCESS;
20335 }
20336
20337 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20338 {
20339         ndr_print_struct(ndr, name, "spoolss_SetJob");
20340         ndr->depth++;
20341         if (flags & NDR_SET_VALUES) {
20342                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20343         }
20344         if (flags & NDR_IN) {
20345                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20346                 ndr->depth++;
20347                 ndr_print_ptr(ndr, "handle", r->in.handle);
20348                 ndr->depth++;
20349                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20350                 ndr->depth--;
20351                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20352                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20353                 ndr->depth++;
20354                 if (r->in.ctr) {
20355                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20356                 }
20357                 ndr->depth--;
20358                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20359                 ndr->depth--;
20360         }
20361         if (flags & NDR_OUT) {
20362                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20363                 ndr->depth++;
20364                 ndr_print_WERROR(ndr, "result", r->out.result);
20365                 ndr->depth--;
20366         }
20367         ndr->depth--;
20368 }
20369
20370 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20371 {
20372         if (flags & NDR_IN) {
20373                 if (r->in.handle == NULL) {
20374                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20375                 }
20376                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20380                 if (r->in.buffer) {
20381                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20382                 }
20383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20384         }
20385         if (flags & NDR_OUT) {
20386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20387                 if (r->out.info) {
20388                         {
20389                                 struct ndr_push *_ndr_info;
20390                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20391                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20392                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20393                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20394                         }
20395                 }
20396                 if (r->out.needed == NULL) {
20397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20398                 }
20399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20401         }
20402         return NDR_ERR_SUCCESS;
20403 }
20404
20405 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20406 {
20407         uint32_t _ptr_buffer;
20408         uint32_t _ptr_info;
20409         TALLOC_CTX *_mem_save_handle_0;
20410         TALLOC_CTX *_mem_save_buffer_0;
20411         TALLOC_CTX *_mem_save_info_0;
20412         TALLOC_CTX *_mem_save_needed_0;
20413         if (flags & NDR_IN) {
20414                 ZERO_STRUCT(r->out);
20415
20416                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20417                         NDR_PULL_ALLOC(ndr, r->in.handle);
20418                 }
20419                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20420                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20421                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20422                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20426                 if (_ptr_buffer) {
20427                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20428                 } else {
20429                         r->in.buffer = NULL;
20430                 }
20431                 if (r->in.buffer) {
20432                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20433                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20434                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20436                 }
20437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20438                 NDR_PULL_ALLOC(ndr, r->out.needed);
20439                 ZERO_STRUCTP(r->out.needed);
20440         }
20441         if (flags & NDR_OUT) {
20442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20443                 if (_ptr_info) {
20444                         NDR_PULL_ALLOC(ndr, r->out.info);
20445                 } else {
20446                         r->out.info = NULL;
20447                 }
20448                 if (r->out.info) {
20449                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20450                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20451                         {
20452                                 struct ndr_pull *_ndr_info;
20453                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20454                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20455                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20456                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20457                         }
20458                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20459                 }
20460                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20461                         NDR_PULL_ALLOC(ndr, r->out.needed);
20462                 }
20463                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20464                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20467                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20468         }
20469         return NDR_ERR_SUCCESS;
20470 }
20471
20472 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20473 {
20474         ndr_print_struct(ndr, name, "spoolss_GetJob");
20475         ndr->depth++;
20476         if (flags & NDR_SET_VALUES) {
20477                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20478         }
20479         if (flags & NDR_IN) {
20480                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
20481                 ndr->depth++;
20482                 ndr_print_ptr(ndr, "handle", r->in.handle);
20483                 ndr->depth++;
20484                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20485                 ndr->depth--;
20486                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20487                 ndr_print_uint32(ndr, "level", r->in.level);
20488                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20489                 ndr->depth++;
20490                 if (r->in.buffer) {
20491                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20492                 }
20493                 ndr->depth--;
20494                 ndr_print_uint32(ndr, "offered", r->in.offered);
20495                 ndr->depth--;
20496         }
20497         if (flags & NDR_OUT) {
20498                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
20499                 ndr->depth++;
20500                 ndr_print_ptr(ndr, "info", r->out.info);
20501                 ndr->depth++;
20502                 if (r->out.info) {
20503                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20504                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20505                 }
20506                 ndr->depth--;
20507                 ndr_print_ptr(ndr, "needed", r->out.needed);
20508                 ndr->depth++;
20509                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20510                 ndr->depth--;
20511                 ndr_print_WERROR(ndr, "result", r->out.result);
20512                 ndr->depth--;
20513         }
20514         ndr->depth--;
20515 }
20516
20517 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20518 {
20519         if (flags & NDR_IN) {
20520                 if (r->in.handle == NULL) {
20521                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20522                 }
20523                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20528                 if (r->in.buffer) {
20529                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20530                 }
20531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20532         }
20533         if (flags & NDR_OUT) {
20534                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20535                 if (r->out.info) {
20536                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20537                 }
20538                 if (r->out.needed == NULL) {
20539                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20540                 }
20541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20542                 if (r->out.count == NULL) {
20543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20544                 }
20545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20546                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20547         }
20548         return NDR_ERR_SUCCESS;
20549 }
20550
20551 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20552 {
20553         uint32_t _ptr_buffer;
20554         uint32_t _ptr_info;
20555         TALLOC_CTX *_mem_save_handle_0;
20556         TALLOC_CTX *_mem_save_buffer_0;
20557         TALLOC_CTX *_mem_save_info_0;
20558         TALLOC_CTX *_mem_save_needed_0;
20559         TALLOC_CTX *_mem_save_count_0;
20560         if (flags & NDR_IN) {
20561                 ZERO_STRUCT(r->out);
20562
20563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20564                         NDR_PULL_ALLOC(ndr, r->in.handle);
20565                 }
20566                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20567                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20568                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20574                 if (_ptr_buffer) {
20575                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20576                 } else {
20577                         r->in.buffer = NULL;
20578                 }
20579                 if (r->in.buffer) {
20580                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20581                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20582                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20584                 }
20585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20586                 NDR_PULL_ALLOC(ndr, r->out.needed);
20587                 ZERO_STRUCTP(r->out.needed);
20588                 NDR_PULL_ALLOC(ndr, r->out.count);
20589                 ZERO_STRUCTP(r->out.count);
20590         }
20591         if (flags & NDR_OUT) {
20592                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20593                 if (_ptr_info) {
20594                         NDR_PULL_ALLOC(ndr, r->out.info);
20595                 } else {
20596                         r->out.info = NULL;
20597                 }
20598                 if (r->out.info) {
20599                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20600                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20601                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20603                 }
20604                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20605                         NDR_PULL_ALLOC(ndr, r->out.needed);
20606                 }
20607                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20608                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20610                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20611                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20612                         NDR_PULL_ALLOC(ndr, r->out.count);
20613                 }
20614                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20615                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20618                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20619         }
20620         return NDR_ERR_SUCCESS;
20621 }
20622
20623 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20624 {
20625         uint32_t cntr_info_0;
20626         if (flags & NDR_IN) {
20627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20629         }
20630         if (flags & NDR_OUT) {
20631                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20632                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20633                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20634                 }
20635                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20636                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20637                 }
20638         }
20639         return NDR_ERR_SUCCESS;
20640 }
20641
20642 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20643 {
20644         uint32_t cntr_info_0;
20645         TALLOC_CTX *_mem_save_info_0;
20646         if (flags & NDR_IN) {
20647                 ZERO_STRUCT(r->out);
20648
20649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20651         }
20652         if (flags & NDR_OUT) {
20653                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20654                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20655                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20656                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20657                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20658                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20659                 }
20660                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20661                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20662                 }
20663                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20664         }
20665         return NDR_ERR_SUCCESS;
20666 }
20667
20668 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20669 {
20670         uint32_t cntr_info_2;
20671         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20672         ndr->depth++;
20673         if (flags & NDR_SET_VALUES) {
20674                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20675         }
20676         if (flags & NDR_IN) {
20677                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20678                 ndr->depth++;
20679                 ndr_print_ptr(ndr, "handle", r->in.handle);
20680                 ndr->depth++;
20681                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20682                 ndr->depth--;
20683                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20684                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20685                 ndr_print_uint32(ndr, "level", r->in.level);
20686                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20687                 ndr->depth++;
20688                 if (r->in.buffer) {
20689                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20690                 }
20691                 ndr->depth--;
20692                 ndr_print_uint32(ndr, "offered", r->in.offered);
20693                 ndr->depth--;
20694         }
20695         if (flags & NDR_OUT) {
20696                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20697                 ndr->depth++;
20698                 ndr_print_ptr(ndr, "count", r->out.count);
20699                 ndr->depth++;
20700                 ndr_print_uint32(ndr, "count", *r->out.count);
20701                 ndr->depth--;
20702                 ndr_print_ptr(ndr, "info", r->out.info);
20703                 ndr->depth++;
20704                 ndr_print_ptr(ndr, "info", *r->out.info);
20705                 ndr->depth++;
20706                 if (*r->out.info) {
20707                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20708                         ndr->depth++;
20709                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20710                                 char *idx_2=NULL;
20711                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20712                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20713                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20714                                         free(idx_2);
20715                                 }
20716                         }
20717                         ndr->depth--;
20718                 }
20719                 ndr->depth--;
20720                 ndr->depth--;
20721                 ndr_print_ptr(ndr, "needed", r->out.needed);
20722                 ndr->depth++;
20723                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20724                 ndr->depth--;
20725                 ndr_print_WERROR(ndr, "result", r->out.result);
20726                 ndr->depth--;
20727         }
20728         ndr->depth--;
20729 }
20730
20731 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20732 {
20733         if (flags & NDR_IN) {
20734                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20735                 if (r->in.server) {
20736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20737                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20740                 }
20741                 if (r->in.info_ctr == NULL) {
20742                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20743                 }
20744                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20745                 if (r->in.devmode_ctr == NULL) {
20746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20747                 }
20748                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20749                 if (r->in.secdesc_ctr == NULL) {
20750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20751                 }
20752                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20753         }
20754         if (flags & NDR_OUT) {
20755                 if (r->out.handle == NULL) {
20756                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20757                 }
20758                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20759                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20760         }
20761         return NDR_ERR_SUCCESS;
20762 }
20763
20764 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20765 {
20766         uint32_t _ptr_server;
20767         TALLOC_CTX *_mem_save_server_0;
20768         TALLOC_CTX *_mem_save_info_ctr_0;
20769         TALLOC_CTX *_mem_save_devmode_ctr_0;
20770         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20771         TALLOC_CTX *_mem_save_handle_0;
20772         if (flags & NDR_IN) {
20773                 ZERO_STRUCT(r->out);
20774
20775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20776                 if (_ptr_server) {
20777                         NDR_PULL_ALLOC(ndr, r->in.server);
20778                 } else {
20779                         r->in.server = NULL;
20780                 }
20781                 if (r->in.server) {
20782                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20783                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20785                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20786                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20787                                 return 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));
20788                         }
20789                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20790                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20792                 }
20793                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20794                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20795                 }
20796                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20797                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20798                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20799                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20801                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20802                 }
20803                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20804                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20805                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20808                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20809                 }
20810                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20811                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20812                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20814                 NDR_PULL_ALLOC(ndr, r->out.handle);
20815                 ZERO_STRUCTP(r->out.handle);
20816         }
20817         if (flags & NDR_OUT) {
20818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20819                         NDR_PULL_ALLOC(ndr, r->out.handle);
20820                 }
20821                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20822                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20823                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20825                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20826         }
20827         return NDR_ERR_SUCCESS;
20828 }
20829
20830 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20831 {
20832         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20833         ndr->depth++;
20834         if (flags & NDR_SET_VALUES) {
20835                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20836         }
20837         if (flags & NDR_IN) {
20838                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20839                 ndr->depth++;
20840                 ndr_print_ptr(ndr, "server", r->in.server);
20841                 ndr->depth++;
20842                 if (r->in.server) {
20843                         ndr_print_string(ndr, "server", r->in.server);
20844                 }
20845                 ndr->depth--;
20846                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20847                 ndr->depth++;
20848                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20849                 ndr->depth--;
20850                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20851                 ndr->depth++;
20852                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20853                 ndr->depth--;
20854                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20855                 ndr->depth++;
20856                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20857                 ndr->depth--;
20858                 ndr->depth--;
20859         }
20860         if (flags & NDR_OUT) {
20861                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
20862                 ndr->depth++;
20863                 ndr_print_ptr(ndr, "handle", r->out.handle);
20864                 ndr->depth++;
20865                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20866                 ndr->depth--;
20867                 ndr_print_WERROR(ndr, "result", r->out.result);
20868                 ndr->depth--;
20869         }
20870         ndr->depth--;
20871 }
20872
20873 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
20874 {
20875         if (flags & NDR_IN) {
20876                 if (r->in.handle == NULL) {
20877                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20878                 }
20879                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20880         }
20881         if (flags & NDR_OUT) {
20882                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20883         }
20884         return NDR_ERR_SUCCESS;
20885 }
20886
20887 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
20888 {
20889         TALLOC_CTX *_mem_save_handle_0;
20890         if (flags & NDR_IN) {
20891                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20892                         NDR_PULL_ALLOC(ndr, r->in.handle);
20893                 }
20894                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20895                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20896                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20898         }
20899         if (flags & NDR_OUT) {
20900                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20901         }
20902         return NDR_ERR_SUCCESS;
20903 }
20904
20905 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
20906 {
20907         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
20908         ndr->depth++;
20909         if (flags & NDR_SET_VALUES) {
20910                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20911         }
20912         if (flags & NDR_IN) {
20913                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
20914                 ndr->depth++;
20915                 ndr_print_ptr(ndr, "handle", r->in.handle);
20916                 ndr->depth++;
20917                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20918                 ndr->depth--;
20919                 ndr->depth--;
20920         }
20921         if (flags & NDR_OUT) {
20922                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
20923                 ndr->depth++;
20924                 ndr_print_WERROR(ndr, "result", r->out.result);
20925                 ndr->depth--;
20926         }
20927         ndr->depth--;
20928 }
20929
20930 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
20931 {
20932         if (flags & NDR_IN) {
20933                 if (r->in.handle == NULL) {
20934                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20935                 }
20936                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20937                 if (r->in.info_ctr == NULL) {
20938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20939                 }
20940                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20941                 if (r->in.devmode_ctr == NULL) {
20942                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20943                 }
20944                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20945                 if (r->in.secdesc_ctr == NULL) {
20946                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20947                 }
20948                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20949                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
20950         }
20951         if (flags & NDR_OUT) {
20952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20953         }
20954         return NDR_ERR_SUCCESS;
20955 }
20956
20957 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
20958 {
20959         TALLOC_CTX *_mem_save_handle_0;
20960         TALLOC_CTX *_mem_save_info_ctr_0;
20961         TALLOC_CTX *_mem_save_devmode_ctr_0;
20962         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20963         if (flags & NDR_IN) {
20964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20965                         NDR_PULL_ALLOC(ndr, r->in.handle);
20966                 }
20967                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20968                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20969                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20972                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20973                 }
20974                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20975                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20976                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20977                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20979                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20980                 }
20981                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20982                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20983                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20986                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20987                 }
20988                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20989                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20990                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20992                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
20993         }
20994         if (flags & NDR_OUT) {
20995                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20996         }
20997         return NDR_ERR_SUCCESS;
20998 }
20999
21000 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21001 {
21002         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21003         ndr->depth++;
21004         if (flags & NDR_SET_VALUES) {
21005                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21006         }
21007         if (flags & NDR_IN) {
21008                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21009                 ndr->depth++;
21010                 ndr_print_ptr(ndr, "handle", r->in.handle);
21011                 ndr->depth++;
21012                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21013                 ndr->depth--;
21014                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21015                 ndr->depth++;
21016                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21017                 ndr->depth--;
21018                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21019                 ndr->depth++;
21020                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21021                 ndr->depth--;
21022                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21023                 ndr->depth++;
21024                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21025                 ndr->depth--;
21026                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21027                 ndr->depth--;
21028         }
21029         if (flags & NDR_OUT) {
21030                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21031                 ndr->depth++;
21032                 ndr_print_WERROR(ndr, "result", r->out.result);
21033                 ndr->depth--;
21034         }
21035         ndr->depth--;
21036 }
21037
21038 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21039 {
21040         if (flags & NDR_IN) {
21041                 if (r->in.handle == NULL) {
21042                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21043                 }
21044                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21047                 if (r->in.buffer) {
21048                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21049                 }
21050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21051         }
21052         if (flags & NDR_OUT) {
21053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21054                 if (r->out.info) {
21055                         {
21056                                 struct ndr_push *_ndr_info;
21057                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21058                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21059                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21060                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21061                         }
21062                 }
21063                 if (r->out.needed == NULL) {
21064                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21065                 }
21066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21067                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21068         }
21069         return NDR_ERR_SUCCESS;
21070 }
21071
21072 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21073 {
21074         uint32_t _ptr_buffer;
21075         uint32_t _ptr_info;
21076         TALLOC_CTX *_mem_save_handle_0;
21077         TALLOC_CTX *_mem_save_buffer_0;
21078         TALLOC_CTX *_mem_save_info_0;
21079         TALLOC_CTX *_mem_save_needed_0;
21080         if (flags & NDR_IN) {
21081                 ZERO_STRUCT(r->out);
21082
21083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21084                         NDR_PULL_ALLOC(ndr, r->in.handle);
21085                 }
21086                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21087                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21092                 if (_ptr_buffer) {
21093                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21094                 } else {
21095                         r->in.buffer = NULL;
21096                 }
21097                 if (r->in.buffer) {
21098                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21099                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21100                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21102                 }
21103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21104                 NDR_PULL_ALLOC(ndr, r->out.needed);
21105                 ZERO_STRUCTP(r->out.needed);
21106         }
21107         if (flags & NDR_OUT) {
21108                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21109                 if (_ptr_info) {
21110                         NDR_PULL_ALLOC(ndr, r->out.info);
21111                 } else {
21112                         r->out.info = NULL;
21113                 }
21114                 if (r->out.info) {
21115                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21116                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21117                         {
21118                                 struct ndr_pull *_ndr_info;
21119                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21120                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21121                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21122                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21123                         }
21124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21125                 }
21126                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21127                         NDR_PULL_ALLOC(ndr, r->out.needed);
21128                 }
21129                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21130                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21132                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21133                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21134         }
21135         return NDR_ERR_SUCCESS;
21136 }
21137
21138 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21139 {
21140         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21141         ndr->depth++;
21142         if (flags & NDR_SET_VALUES) {
21143                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21144         }
21145         if (flags & NDR_IN) {
21146                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21147                 ndr->depth++;
21148                 ndr_print_ptr(ndr, "handle", r->in.handle);
21149                 ndr->depth++;
21150                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21151                 ndr->depth--;
21152                 ndr_print_uint32(ndr, "level", r->in.level);
21153                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21154                 ndr->depth++;
21155                 if (r->in.buffer) {
21156                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21157                 }
21158                 ndr->depth--;
21159                 ndr_print_uint32(ndr, "offered", r->in.offered);
21160                 ndr->depth--;
21161         }
21162         if (flags & NDR_OUT) {
21163                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21164                 ndr->depth++;
21165                 ndr_print_ptr(ndr, "info", r->out.info);
21166                 ndr->depth++;
21167                 if (r->out.info) {
21168                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21169                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21170                 }
21171                 ndr->depth--;
21172                 ndr_print_ptr(ndr, "needed", r->out.needed);
21173                 ndr->depth++;
21174                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21175                 ndr->depth--;
21176                 ndr_print_WERROR(ndr, "result", r->out.result);
21177                 ndr->depth--;
21178         }
21179         ndr->depth--;
21180 }
21181
21182 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21183 {
21184         if (flags & NDR_IN) {
21185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21186                 if (r->in.servername) {
21187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21190                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21191                 }
21192                 if (r->in.info_ctr == NULL) {
21193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21194                 }
21195                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21196         }
21197         if (flags & NDR_OUT) {
21198                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21199         }
21200         return NDR_ERR_SUCCESS;
21201 }
21202
21203 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21204 {
21205         uint32_t _ptr_servername;
21206         TALLOC_CTX *_mem_save_servername_0;
21207         TALLOC_CTX *_mem_save_info_ctr_0;
21208         if (flags & NDR_IN) {
21209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21210                 if (_ptr_servername) {
21211                         NDR_PULL_ALLOC(ndr, r->in.servername);
21212                 } else {
21213                         r->in.servername = NULL;
21214                 }
21215                 if (r->in.servername) {
21216                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21217                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21218                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21219                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21220                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21221                                 return 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));
21222                         }
21223                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21224                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21225                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21226                 }
21227                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21228                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21229                 }
21230                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21231                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21232                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21233                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21234         }
21235         if (flags & NDR_OUT) {
21236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21237         }
21238         return NDR_ERR_SUCCESS;
21239 }
21240
21241 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21242 {
21243         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21244         ndr->depth++;
21245         if (flags & NDR_SET_VALUES) {
21246                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21247         }
21248         if (flags & NDR_IN) {
21249                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21250                 ndr->depth++;
21251                 ndr_print_ptr(ndr, "servername", r->in.servername);
21252                 ndr->depth++;
21253                 if (r->in.servername) {
21254                         ndr_print_string(ndr, "servername", r->in.servername);
21255                 }
21256                 ndr->depth--;
21257                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21258                 ndr->depth++;
21259                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21260                 ndr->depth--;
21261                 ndr->depth--;
21262         }
21263         if (flags & NDR_OUT) {
21264                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21265                 ndr->depth++;
21266                 ndr_print_WERROR(ndr, "result", r->out.result);
21267                 ndr->depth--;
21268         }
21269         ndr->depth--;
21270 }
21271
21272 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21273 {
21274         if (flags & NDR_IN) {
21275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21276                 if (r->in.server) {
21277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21278                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21279                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21280                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21281                 }
21282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21283                 if (r->in.environment) {
21284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21288                 }
21289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21291                 if (r->in.buffer) {
21292                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21293                 }
21294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21295         }
21296         if (flags & NDR_OUT) {
21297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21298                 if (r->out.info) {
21299                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21300                 }
21301                 if (r->out.needed == NULL) {
21302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21303                 }
21304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21305                 if (r->out.count == NULL) {
21306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21307                 }
21308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21309                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21310         }
21311         return NDR_ERR_SUCCESS;
21312 }
21313
21314 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21315 {
21316         uint32_t _ptr_server;
21317         uint32_t _ptr_environment;
21318         uint32_t _ptr_buffer;
21319         uint32_t _ptr_info;
21320         TALLOC_CTX *_mem_save_server_0;
21321         TALLOC_CTX *_mem_save_environment_0;
21322         TALLOC_CTX *_mem_save_buffer_0;
21323         TALLOC_CTX *_mem_save_info_0;
21324         TALLOC_CTX *_mem_save_needed_0;
21325         TALLOC_CTX *_mem_save_count_0;
21326         if (flags & NDR_IN) {
21327                 ZERO_STRUCT(r->out);
21328
21329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21330                 if (_ptr_server) {
21331                         NDR_PULL_ALLOC(ndr, r->in.server);
21332                 } else {
21333                         r->in.server = NULL;
21334                 }
21335                 if (r->in.server) {
21336                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21337                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21338                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21339                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21340                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21341                                 return 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));
21342                         }
21343                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21344                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21346                 }
21347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21348                 if (_ptr_environment) {
21349                         NDR_PULL_ALLOC(ndr, r->in.environment);
21350                 } else {
21351                         r->in.environment = NULL;
21352                 }
21353                 if (r->in.environment) {
21354                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21355                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21358                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21359                                 return 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));
21360                         }
21361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21364                 }
21365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21367                 if (_ptr_buffer) {
21368                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21369                 } else {
21370                         r->in.buffer = NULL;
21371                 }
21372                 if (r->in.buffer) {
21373                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21374                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21375                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21376                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21377                 }
21378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21379                 NDR_PULL_ALLOC(ndr, r->out.needed);
21380                 ZERO_STRUCTP(r->out.needed);
21381                 NDR_PULL_ALLOC(ndr, r->out.count);
21382                 ZERO_STRUCTP(r->out.count);
21383         }
21384         if (flags & NDR_OUT) {
21385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21386                 if (_ptr_info) {
21387                         NDR_PULL_ALLOC(ndr, r->out.info);
21388                 } else {
21389                         r->out.info = NULL;
21390                 }
21391                 if (r->out.info) {
21392                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21393                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21394                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21396                 }
21397                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21398                         NDR_PULL_ALLOC(ndr, r->out.needed);
21399                 }
21400                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21401                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21403                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21405                         NDR_PULL_ALLOC(ndr, r->out.count);
21406                 }
21407                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21408                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21411                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21412         }
21413         return NDR_ERR_SUCCESS;
21414 }
21415
21416 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21417 {
21418         uint32_t cntr_info_0;
21419         if (flags & NDR_IN) {
21420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21422         }
21423         if (flags & NDR_OUT) {
21424                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21425                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21426                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21427                 }
21428                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21429                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21430                 }
21431         }
21432         return NDR_ERR_SUCCESS;
21433 }
21434
21435 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21436 {
21437         uint32_t cntr_info_0;
21438         TALLOC_CTX *_mem_save_info_0;
21439         if (flags & NDR_IN) {
21440                 ZERO_STRUCT(r->out);
21441
21442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21444         }
21445         if (flags & NDR_OUT) {
21446                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21447                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21448                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21449                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21450                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21451                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21452                 }
21453                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21454                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21455                 }
21456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21457         }
21458         return NDR_ERR_SUCCESS;
21459 }
21460
21461 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21462 {
21463         uint32_t cntr_info_2;
21464         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21465         ndr->depth++;
21466         if (flags & NDR_SET_VALUES) {
21467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21468         }
21469         if (flags & NDR_IN) {
21470                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21471                 ndr->depth++;
21472                 ndr_print_ptr(ndr, "server", r->in.server);
21473                 ndr->depth++;
21474                 if (r->in.server) {
21475                         ndr_print_string(ndr, "server", r->in.server);
21476                 }
21477                 ndr->depth--;
21478                 ndr_print_ptr(ndr, "environment", r->in.environment);
21479                 ndr->depth++;
21480                 if (r->in.environment) {
21481                         ndr_print_string(ndr, "environment", r->in.environment);
21482                 }
21483                 ndr->depth--;
21484                 ndr_print_uint32(ndr, "level", r->in.level);
21485                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21486                 ndr->depth++;
21487                 if (r->in.buffer) {
21488                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21489                 }
21490                 ndr->depth--;
21491                 ndr_print_uint32(ndr, "offered", r->in.offered);
21492                 ndr->depth--;
21493         }
21494         if (flags & NDR_OUT) {
21495                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21496                 ndr->depth++;
21497                 ndr_print_ptr(ndr, "count", r->out.count);
21498                 ndr->depth++;
21499                 ndr_print_uint32(ndr, "count", *r->out.count);
21500                 ndr->depth--;
21501                 ndr_print_ptr(ndr, "info", r->out.info);
21502                 ndr->depth++;
21503                 ndr_print_ptr(ndr, "info", *r->out.info);
21504                 ndr->depth++;
21505                 if (*r->out.info) {
21506                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21507                         ndr->depth++;
21508                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21509                                 char *idx_2=NULL;
21510                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21511                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21512                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21513                                         free(idx_2);
21514                                 }
21515                         }
21516                         ndr->depth--;
21517                 }
21518                 ndr->depth--;
21519                 ndr->depth--;
21520                 ndr_print_ptr(ndr, "needed", r->out.needed);
21521                 ndr->depth++;
21522                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21523                 ndr->depth--;
21524                 ndr_print_WERROR(ndr, "result", r->out.result);
21525                 ndr->depth--;
21526         }
21527         ndr->depth--;
21528 }
21529
21530 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21531 {
21532         if (flags & NDR_IN) {
21533                 if (r->in.handle == NULL) {
21534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21535                 }
21536                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21538                 if (r->in.architecture) {
21539                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21542                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21543                 }
21544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21545                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21546                 if (r->in.buffer) {
21547                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21548                 }
21549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21550         }
21551         if (flags & NDR_OUT) {
21552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21553                 if (r->out.info) {
21554                         {
21555                                 struct ndr_push *_ndr_info;
21556                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21557                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21558                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21559                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21560                         }
21561                 }
21562                 if (r->out.needed == NULL) {
21563                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21564                 }
21565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21566                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21567         }
21568         return NDR_ERR_SUCCESS;
21569 }
21570
21571 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
21572 {
21573         uint32_t _ptr_architecture;
21574         uint32_t _ptr_buffer;
21575         uint32_t _ptr_info;
21576         TALLOC_CTX *_mem_save_handle_0;
21577         TALLOC_CTX *_mem_save_architecture_0;
21578         TALLOC_CTX *_mem_save_buffer_0;
21579         TALLOC_CTX *_mem_save_info_0;
21580         TALLOC_CTX *_mem_save_needed_0;
21581         if (flags & NDR_IN) {
21582                 ZERO_STRUCT(r->out);
21583
21584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21585                         NDR_PULL_ALLOC(ndr, r->in.handle);
21586                 }
21587                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21588                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21589                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21591                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21592                 if (_ptr_architecture) {
21593                         NDR_PULL_ALLOC(ndr, r->in.architecture);
21594                 } else {
21595                         r->in.architecture = NULL;
21596                 }
21597                 if (r->in.architecture) {
21598                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21599                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21600                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21601                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21602                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21603                                 return 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));
21604                         }
21605                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21606                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21608                 }
21609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21610                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21611                 if (_ptr_buffer) {
21612                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21613                 } else {
21614                         r->in.buffer = NULL;
21615                 }
21616                 if (r->in.buffer) {
21617                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21618                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21619                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21621                 }
21622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21623                 NDR_PULL_ALLOC(ndr, r->out.needed);
21624                 ZERO_STRUCTP(r->out.needed);
21625         }
21626         if (flags & NDR_OUT) {
21627                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21628                 if (_ptr_info) {
21629                         NDR_PULL_ALLOC(ndr, r->out.info);
21630                 } else {
21631                         r->out.info = NULL;
21632                 }
21633                 if (r->out.info) {
21634                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21635                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21636                         {
21637                                 struct ndr_pull *_ndr_info;
21638                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21639                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21640                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21641                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21642                         }
21643                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21644                 }
21645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21646                         NDR_PULL_ALLOC(ndr, r->out.needed);
21647                 }
21648                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21649                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21651                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21652                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21653         }
21654         return NDR_ERR_SUCCESS;
21655 }
21656
21657 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21658 {
21659         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21660         ndr->depth++;
21661         if (flags & NDR_SET_VALUES) {
21662                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21663         }
21664         if (flags & NDR_IN) {
21665                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21666                 ndr->depth++;
21667                 ndr_print_ptr(ndr, "handle", r->in.handle);
21668                 ndr->depth++;
21669                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21670                 ndr->depth--;
21671                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21672                 ndr->depth++;
21673                 if (r->in.architecture) {
21674                         ndr_print_string(ndr, "architecture", r->in.architecture);
21675                 }
21676                 ndr->depth--;
21677                 ndr_print_uint32(ndr, "level", r->in.level);
21678                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21679                 ndr->depth++;
21680                 if (r->in.buffer) {
21681                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21682                 }
21683                 ndr->depth--;
21684                 ndr_print_uint32(ndr, "offered", r->in.offered);
21685                 ndr->depth--;
21686         }
21687         if (flags & NDR_OUT) {
21688                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
21689                 ndr->depth++;
21690                 ndr_print_ptr(ndr, "info", r->out.info);
21691                 ndr->depth++;
21692                 if (r->out.info) {
21693                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21694                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
21695                 }
21696                 ndr->depth--;
21697                 ndr_print_ptr(ndr, "needed", r->out.needed);
21698                 ndr->depth++;
21699                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21700                 ndr->depth--;
21701                 ndr_print_WERROR(ndr, "result", r->out.result);
21702                 ndr->depth--;
21703         }
21704         ndr->depth--;
21705 }
21706
21707 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21708 {
21709         if (flags & NDR_IN) {
21710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21711                 if (r->in.server) {
21712                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21713                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21716                 }
21717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21718                 if (r->in.environment) {
21719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21723                 }
21724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21726                 if (r->in.buffer) {
21727                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21728                 }
21729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21730         }
21731         if (flags & NDR_OUT) {
21732                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21733                 if (r->out.info) {
21734                         {
21735                                 struct ndr_push *_ndr_info;
21736                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21737                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21738                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21739                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21740                         }
21741                 }
21742                 if (r->out.needed == NULL) {
21743                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21744                 }
21745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21747         }
21748         return NDR_ERR_SUCCESS;
21749 }
21750
21751 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
21752 {
21753         uint32_t _ptr_server;
21754         uint32_t _ptr_environment;
21755         uint32_t _ptr_buffer;
21756         uint32_t _ptr_info;
21757         TALLOC_CTX *_mem_save_server_0;
21758         TALLOC_CTX *_mem_save_environment_0;
21759         TALLOC_CTX *_mem_save_buffer_0;
21760         TALLOC_CTX *_mem_save_info_0;
21761         TALLOC_CTX *_mem_save_needed_0;
21762         if (flags & NDR_IN) {
21763                 ZERO_STRUCT(r->out);
21764
21765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21766                 if (_ptr_server) {
21767                         NDR_PULL_ALLOC(ndr, r->in.server);
21768                 } else {
21769                         r->in.server = NULL;
21770                 }
21771                 if (r->in.server) {
21772                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21774                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21775                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21776                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21777                                 return 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));
21778                         }
21779                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21780                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21782                 }
21783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21784                 if (_ptr_environment) {
21785                         NDR_PULL_ALLOC(ndr, r->in.environment);
21786                 } else {
21787                         r->in.environment = NULL;
21788                 }
21789                 if (r->in.environment) {
21790                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21794                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21795                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
21796                         }
21797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21800                 }
21801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21803                 if (_ptr_buffer) {
21804                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21805                 } else {
21806                         r->in.buffer = NULL;
21807                 }
21808                 if (r->in.buffer) {
21809                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21811                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21813                 }
21814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21815                 NDR_PULL_ALLOC(ndr, r->out.needed);
21816                 ZERO_STRUCTP(r->out.needed);
21817         }
21818         if (flags & NDR_OUT) {
21819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21820                 if (_ptr_info) {
21821                         NDR_PULL_ALLOC(ndr, r->out.info);
21822                 } else {
21823                         r->out.info = NULL;
21824                 }
21825                 if (r->out.info) {
21826                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21827                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21828                         {
21829                                 struct ndr_pull *_ndr_info;
21830                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21831                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21832                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21833                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21834                         }
21835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21836                 }
21837                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21838                         NDR_PULL_ALLOC(ndr, r->out.needed);
21839                 }
21840                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21841                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21843                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21844                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21845         }
21846         return NDR_ERR_SUCCESS;
21847 }
21848
21849 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21850 {
21851         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
21852         ndr->depth++;
21853         if (flags & NDR_SET_VALUES) {
21854                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21855         }
21856         if (flags & NDR_IN) {
21857                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
21858                 ndr->depth++;
21859                 ndr_print_ptr(ndr, "server", r->in.server);
21860                 ndr->depth++;
21861                 if (r->in.server) {
21862                         ndr_print_string(ndr, "server", r->in.server);
21863                 }
21864                 ndr->depth--;
21865                 ndr_print_ptr(ndr, "environment", r->in.environment);
21866                 ndr->depth++;
21867                 if (r->in.environment) {
21868                         ndr_print_string(ndr, "environment", r->in.environment);
21869                 }
21870                 ndr->depth--;
21871                 ndr_print_uint32(ndr, "level", r->in.level);
21872                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21873                 ndr->depth++;
21874                 if (r->in.buffer) {
21875                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21876                 }
21877                 ndr->depth--;
21878                 ndr_print_uint32(ndr, "offered", r->in.offered);
21879                 ndr->depth--;
21880         }
21881         if (flags & NDR_OUT) {
21882                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
21883                 ndr->depth++;
21884                 ndr_print_ptr(ndr, "info", r->out.info);
21885                 ndr->depth++;
21886                 if (r->out.info) {
21887                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21888                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
21889                 }
21890                 ndr->depth--;
21891                 ndr_print_ptr(ndr, "needed", r->out.needed);
21892                 ndr->depth++;
21893                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21894                 ndr->depth--;
21895                 ndr_print_WERROR(ndr, "result", r->out.result);
21896                 ndr->depth--;
21897         }
21898         ndr->depth--;
21899 }
21900
21901 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
21902 {
21903         if (flags & NDR_IN) {
21904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21905                 if (r->in.server) {
21906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, 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.server, CH_UTF16)));
21909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21910                 }
21911                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21912                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21913                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21914                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21915                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21916                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21917                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21918                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21919         }
21920         if (flags & NDR_OUT) {
21921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21922         }
21923         return NDR_ERR_SUCCESS;
21924 }
21925
21926 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
21927 {
21928         uint32_t _ptr_server;
21929         TALLOC_CTX *_mem_save_server_0;
21930         if (flags & NDR_IN) {
21931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21932                 if (_ptr_server) {
21933                         NDR_PULL_ALLOC(ndr, r->in.server);
21934                 } else {
21935                         r->in.server = NULL;
21936                 }
21937                 if (r->in.server) {
21938                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21942                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
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.server), ndr_get_array_length(ndr, &r->in.server));
21944                         }
21945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21948                 }
21949                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21950                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21951                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21952                         return 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));
21953                 }
21954                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21955                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21956                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
21957                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
21958                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
21959                         return 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));
21960                 }
21961                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
21962                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
21963         }
21964         if (flags & NDR_OUT) {
21965                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21966         }
21967         return NDR_ERR_SUCCESS;
21968 }
21969
21970 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
21971 {
21972         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
21973         ndr->depth++;
21974         if (flags & NDR_SET_VALUES) {
21975                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21976         }
21977         if (flags & NDR_IN) {
21978                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
21979                 ndr->depth++;
21980                 ndr_print_ptr(ndr, "server", r->in.server);
21981                 ndr->depth++;
21982                 if (r->in.server) {
21983                         ndr_print_string(ndr, "server", r->in.server);
21984                 }
21985                 ndr->depth--;
21986                 ndr_print_string(ndr, "architecture", r->in.architecture);
21987                 ndr_print_string(ndr, "driver", r->in.driver);
21988                 ndr->depth--;
21989         }
21990         if (flags & NDR_OUT) {
21991                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
21992                 ndr->depth++;
21993                 ndr_print_WERROR(ndr, "result", r->out.result);
21994                 ndr->depth--;
21995         }
21996         ndr->depth--;
21997 }
21998
21999 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22000 {
22001         if (flags & NDR_IN) {
22002                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22003                 if (r->in.server) {
22004                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, 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.server, CH_UTF16)));
22007                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22008                 }
22009                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22010                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22011                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22012                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22013                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22014                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22015                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22016                 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));
22017                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22018                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22019                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22020                 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));
22021         }
22022         if (flags & NDR_OUT) {
22023                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22024         }
22025         return NDR_ERR_SUCCESS;
22026 }
22027
22028 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22029 {
22030         uint32_t _ptr_server;
22031         TALLOC_CTX *_mem_save_server_0;
22032         if (flags & NDR_IN) {
22033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22034                 if (_ptr_server) {
22035                         NDR_PULL_ALLOC(ndr, r->in.server);
22036                 } else {
22037                         r->in.server = NULL;
22038                 }
22039                 if (r->in.server) {
22040                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22041                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22044                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
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.server), ndr_get_array_length(ndr, &r->in.server));
22046                         }
22047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22050                 }
22051                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22052                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22053                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22054                         return 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));
22055                 }
22056                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22057                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22058                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22059                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22060                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22061                         return 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));
22062                 }
22063                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22064                 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));
22065                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22066                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22067                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22068                         return 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));
22069                 }
22070                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22071                 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));
22072         }
22073         if (flags & NDR_OUT) {
22074                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22075         }
22076         return NDR_ERR_SUCCESS;
22077 }
22078
22079 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22080 {
22081         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22082         ndr->depth++;
22083         if (flags & NDR_SET_VALUES) {
22084                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22085         }
22086         if (flags & NDR_IN) {
22087                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22088                 ndr->depth++;
22089                 ndr_print_ptr(ndr, "server", r->in.server);
22090                 ndr->depth++;
22091                 if (r->in.server) {
22092                         ndr_print_string(ndr, "server", r->in.server);
22093                 }
22094                 ndr->depth--;
22095                 ndr_print_string(ndr, "architecture", r->in.architecture);
22096                 ndr_print_string(ndr, "path_name", r->in.path_name);
22097                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22098                 ndr->depth--;
22099         }
22100         if (flags & NDR_OUT) {
22101                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22102                 ndr->depth++;
22103                 ndr_print_WERROR(ndr, "result", r->out.result);
22104                 ndr->depth--;
22105         }
22106         ndr->depth--;
22107 }
22108
22109 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22110 {
22111         if (flags & NDR_IN) {
22112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22113                 if (r->in.servername) {
22114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22116                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22117                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22118                 }
22119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22120                 if (r->in.environment) {
22121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22122                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22123                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22125                 }
22126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22128                 if (r->in.buffer) {
22129                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22130                 }
22131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22132         }
22133         if (flags & NDR_OUT) {
22134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22135                 if (r->out.info) {
22136                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22137                 }
22138                 if (r->out.needed == NULL) {
22139                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22140                 }
22141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22142                 if (r->out.count == NULL) {
22143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22144                 }
22145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22146                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22147         }
22148         return NDR_ERR_SUCCESS;
22149 }
22150
22151 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22152 {
22153         uint32_t _ptr_servername;
22154         uint32_t _ptr_environment;
22155         uint32_t _ptr_buffer;
22156         uint32_t _ptr_info;
22157         TALLOC_CTX *_mem_save_servername_0;
22158         TALLOC_CTX *_mem_save_environment_0;
22159         TALLOC_CTX *_mem_save_buffer_0;
22160         TALLOC_CTX *_mem_save_info_0;
22161         TALLOC_CTX *_mem_save_needed_0;
22162         TALLOC_CTX *_mem_save_count_0;
22163         if (flags & NDR_IN) {
22164                 ZERO_STRUCT(r->out);
22165
22166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22167                 if (_ptr_servername) {
22168                         NDR_PULL_ALLOC(ndr, r->in.servername);
22169                 } else {
22170                         r->in.servername = NULL;
22171                 }
22172                 if (r->in.servername) {
22173                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22174                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22175                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22176                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22177                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22178                                 return 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));
22179                         }
22180                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22181                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22183                 }
22184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22185                 if (_ptr_environment) {
22186                         NDR_PULL_ALLOC(ndr, r->in.environment);
22187                 } else {
22188                         r->in.environment = NULL;
22189                 }
22190                 if (r->in.environment) {
22191                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22192                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22194                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22195                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22196                                 return 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));
22197                         }
22198                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22199                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22201                 }
22202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22203                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22204                 if (_ptr_buffer) {
22205                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22206                 } else {
22207                         r->in.buffer = NULL;
22208                 }
22209                 if (r->in.buffer) {
22210                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22211                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22212                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22213                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22214                 }
22215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22216                 NDR_PULL_ALLOC(ndr, r->out.needed);
22217                 ZERO_STRUCTP(r->out.needed);
22218                 NDR_PULL_ALLOC(ndr, r->out.count);
22219                 ZERO_STRUCTP(r->out.count);
22220         }
22221         if (flags & NDR_OUT) {
22222                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22223                 if (_ptr_info) {
22224                         NDR_PULL_ALLOC(ndr, r->out.info);
22225                 } else {
22226                         r->out.info = NULL;
22227                 }
22228                 if (r->out.info) {
22229                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22230                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22231                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22232                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22233                 }
22234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22235                         NDR_PULL_ALLOC(ndr, r->out.needed);
22236                 }
22237                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22238                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22241                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22242                         NDR_PULL_ALLOC(ndr, r->out.count);
22243                 }
22244                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22245                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22247                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22248                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22249         }
22250         return NDR_ERR_SUCCESS;
22251 }
22252
22253 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22254 {
22255         uint32_t cntr_info_0;
22256         if (flags & NDR_IN) {
22257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22259         }
22260         if (flags & NDR_OUT) {
22261                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22262                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22263                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22264                 }
22265                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22266                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22267                 }
22268         }
22269         return NDR_ERR_SUCCESS;
22270 }
22271
22272 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22273 {
22274         uint32_t cntr_info_0;
22275         TALLOC_CTX *_mem_save_info_0;
22276         if (flags & NDR_IN) {
22277                 ZERO_STRUCT(r->out);
22278
22279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22281         }
22282         if (flags & NDR_OUT) {
22283                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22284                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22285                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22286                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22287                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22288                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22289                 }
22290                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22291                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22292                 }
22293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22294         }
22295         return NDR_ERR_SUCCESS;
22296 }
22297
22298 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22299 {
22300         uint32_t cntr_info_2;
22301         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22302         ndr->depth++;
22303         if (flags & NDR_SET_VALUES) {
22304                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22305         }
22306         if (flags & NDR_IN) {
22307                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22308                 ndr->depth++;
22309                 ndr_print_ptr(ndr, "servername", r->in.servername);
22310                 ndr->depth++;
22311                 if (r->in.servername) {
22312                         ndr_print_string(ndr, "servername", r->in.servername);
22313                 }
22314                 ndr->depth--;
22315                 ndr_print_ptr(ndr, "environment", r->in.environment);
22316                 ndr->depth++;
22317                 if (r->in.environment) {
22318                         ndr_print_string(ndr, "environment", r->in.environment);
22319                 }
22320                 ndr->depth--;
22321                 ndr_print_uint32(ndr, "level", r->in.level);
22322                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22323                 ndr->depth++;
22324                 if (r->in.buffer) {
22325                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22326                 }
22327                 ndr->depth--;
22328                 ndr_print_uint32(ndr, "offered", r->in.offered);
22329                 ndr->depth--;
22330         }
22331         if (flags & NDR_OUT) {
22332                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22333                 ndr->depth++;
22334                 ndr_print_ptr(ndr, "count", r->out.count);
22335                 ndr->depth++;
22336                 ndr_print_uint32(ndr, "count", *r->out.count);
22337                 ndr->depth--;
22338                 ndr_print_ptr(ndr, "info", r->out.info);
22339                 ndr->depth++;
22340                 ndr_print_ptr(ndr, "info", *r->out.info);
22341                 ndr->depth++;
22342                 if (*r->out.info) {
22343                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22344                         ndr->depth++;
22345                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22346                                 char *idx_2=NULL;
22347                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22348                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22349                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22350                                         free(idx_2);
22351                                 }
22352                         }
22353                         ndr->depth--;
22354                 }
22355                 ndr->depth--;
22356                 ndr->depth--;
22357                 ndr_print_ptr(ndr, "needed", r->out.needed);
22358                 ndr->depth++;
22359                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22360                 ndr->depth--;
22361                 ndr_print_WERROR(ndr, "result", r->out.result);
22362                 ndr->depth--;
22363         }
22364         ndr->depth--;
22365 }
22366
22367 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22368 {
22369         if (flags & NDR_IN) {
22370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22371                 if (r->in.server) {
22372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22375                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22376                 }
22377                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22378                 if (r->in.environment) {
22379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22383                 }
22384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22385                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22386                 if (r->in.buffer) {
22387                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22388                 }
22389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22390         }
22391         if (flags & NDR_OUT) {
22392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22393                 if (r->out.info) {
22394                         {
22395                                 struct ndr_push *_ndr_info;
22396                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22397                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22398                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22399                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22400                         }
22401                 }
22402                 if (r->out.needed == NULL) {
22403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22404                 }
22405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22407         }
22408         return NDR_ERR_SUCCESS;
22409 }
22410
22411 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22412 {
22413         uint32_t _ptr_server;
22414         uint32_t _ptr_environment;
22415         uint32_t _ptr_buffer;
22416         uint32_t _ptr_info;
22417         TALLOC_CTX *_mem_save_server_0;
22418         TALLOC_CTX *_mem_save_environment_0;
22419         TALLOC_CTX *_mem_save_buffer_0;
22420         TALLOC_CTX *_mem_save_info_0;
22421         TALLOC_CTX *_mem_save_needed_0;
22422         if (flags & NDR_IN) {
22423                 ZERO_STRUCT(r->out);
22424
22425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22426                 if (_ptr_server) {
22427                         NDR_PULL_ALLOC(ndr, r->in.server);
22428                 } else {
22429                         r->in.server = NULL;
22430                 }
22431                 if (r->in.server) {
22432                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22433                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22434                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22435                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22436                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22437                                 return 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));
22438                         }
22439                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22440                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22442                 }
22443                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22444                 if (_ptr_environment) {
22445                         NDR_PULL_ALLOC(ndr, r->in.environment);
22446                 } else {
22447                         r->in.environment = NULL;
22448                 }
22449                 if (r->in.environment) {
22450                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22451                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22452                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22453                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22454                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22455                                 return 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));
22456                         }
22457                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22458                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22460                 }
22461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22463                 if (_ptr_buffer) {
22464                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22465                 } else {
22466                         r->in.buffer = NULL;
22467                 }
22468                 if (r->in.buffer) {
22469                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22470                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22471                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22473                 }
22474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22475                 NDR_PULL_ALLOC(ndr, r->out.needed);
22476                 ZERO_STRUCTP(r->out.needed);
22477         }
22478         if (flags & NDR_OUT) {
22479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22480                 if (_ptr_info) {
22481                         NDR_PULL_ALLOC(ndr, r->out.info);
22482                 } else {
22483                         r->out.info = NULL;
22484                 }
22485                 if (r->out.info) {
22486                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22487                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22488                         {
22489                                 struct ndr_pull *_ndr_info;
22490                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22491                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22492                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22493                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22494                         }
22495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22496                 }
22497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22498                         NDR_PULL_ALLOC(ndr, r->out.needed);
22499                 }
22500                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22501                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22505         }
22506         return NDR_ERR_SUCCESS;
22507 }
22508
22509 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22510 {
22511         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22512         ndr->depth++;
22513         if (flags & NDR_SET_VALUES) {
22514                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22515         }
22516         if (flags & NDR_IN) {
22517                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22518                 ndr->depth++;
22519                 ndr_print_ptr(ndr, "server", r->in.server);
22520                 ndr->depth++;
22521                 if (r->in.server) {
22522                         ndr_print_string(ndr, "server", r->in.server);
22523                 }
22524                 ndr->depth--;
22525                 ndr_print_ptr(ndr, "environment", r->in.environment);
22526                 ndr->depth++;
22527                 if (r->in.environment) {
22528                         ndr_print_string(ndr, "environment", r->in.environment);
22529                 }
22530                 ndr->depth--;
22531                 ndr_print_uint32(ndr, "level", r->in.level);
22532                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22533                 ndr->depth++;
22534                 if (r->in.buffer) {
22535                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22536                 }
22537                 ndr->depth--;
22538                 ndr_print_uint32(ndr, "offered", r->in.offered);
22539                 ndr->depth--;
22540         }
22541         if (flags & NDR_OUT) {
22542                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22543                 ndr->depth++;
22544                 ndr_print_ptr(ndr, "info", r->out.info);
22545                 ndr->depth++;
22546                 if (r->out.info) {
22547                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22548                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
22549                 }
22550                 ndr->depth--;
22551                 ndr_print_ptr(ndr, "needed", r->out.needed);
22552                 ndr->depth++;
22553                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22554                 ndr->depth--;
22555                 ndr_print_WERROR(ndr, "result", r->out.result);
22556                 ndr->depth--;
22557         }
22558         ndr->depth--;
22559 }
22560
22561 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
22562 {
22563         if (flags & NDR_IN) {
22564                 if (r->in.handle == NULL) {
22565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22566                 }
22567                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22569                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22570                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22571         }
22572         if (flags & NDR_OUT) {
22573                 if (r->out.job_id == NULL) {
22574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22575                 }
22576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
22577                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22578         }
22579         return NDR_ERR_SUCCESS;
22580 }
22581
22582 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22583 {
22584         TALLOC_CTX *_mem_save_handle_0;
22585         TALLOC_CTX *_mem_save_job_id_0;
22586         if (flags & NDR_IN) {
22587                 ZERO_STRUCT(r->out);
22588
22589                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22590                         NDR_PULL_ALLOC(ndr, r->in.handle);
22591                 }
22592                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22593                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22594                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22595                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22597                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22598                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22599                 NDR_PULL_ALLOC(ndr, r->out.job_id);
22600                 ZERO_STRUCTP(r->out.job_id);
22601         }
22602         if (flags & NDR_OUT) {
22603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22604                         NDR_PULL_ALLOC(ndr, r->out.job_id);
22605                 }
22606                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22607                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22610                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22611         }
22612         return NDR_ERR_SUCCESS;
22613 }
22614
22615 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22616 {
22617         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22618         ndr->depth++;
22619         if (flags & NDR_SET_VALUES) {
22620                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22621         }
22622         if (flags & NDR_IN) {
22623                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22624                 ndr->depth++;
22625                 ndr_print_ptr(ndr, "handle", r->in.handle);
22626                 ndr->depth++;
22627                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22628                 ndr->depth--;
22629                 ndr_print_uint32(ndr, "level", r->in.level);
22630                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22631                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22632                 ndr->depth--;
22633         }
22634         if (flags & NDR_OUT) {
22635                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22636                 ndr->depth++;
22637                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
22638                 ndr->depth++;
22639                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22640                 ndr->depth--;
22641                 ndr_print_WERROR(ndr, "result", r->out.result);
22642                 ndr->depth--;
22643         }
22644         ndr->depth--;
22645 }
22646
22647 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22648 {
22649         if (flags & NDR_IN) {
22650                 if (r->in.handle == NULL) {
22651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22652                 }
22653                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22654         }
22655         if (flags & NDR_OUT) {
22656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22657         }
22658         return NDR_ERR_SUCCESS;
22659 }
22660
22661 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22662 {
22663         TALLOC_CTX *_mem_save_handle_0;
22664         if (flags & NDR_IN) {
22665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22666                         NDR_PULL_ALLOC(ndr, r->in.handle);
22667                 }
22668                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22669                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22670                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22672         }
22673         if (flags & NDR_OUT) {
22674                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22675         }
22676         return NDR_ERR_SUCCESS;
22677 }
22678
22679 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22680 {
22681         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22682         ndr->depth++;
22683         if (flags & NDR_SET_VALUES) {
22684                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22685         }
22686         if (flags & NDR_IN) {
22687                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22688                 ndr->depth++;
22689                 ndr_print_ptr(ndr, "handle", r->in.handle);
22690                 ndr->depth++;
22691                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22692                 ndr->depth--;
22693                 ndr->depth--;
22694         }
22695         if (flags & NDR_OUT) {
22696                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
22697                 ndr->depth++;
22698                 ndr_print_WERROR(ndr, "result", r->out.result);
22699                 ndr->depth--;
22700         }
22701         ndr->depth--;
22702 }
22703
22704 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
22705 {
22706         if (flags & NDR_IN) {
22707                 if (r->in.handle == NULL) {
22708                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22709                 }
22710                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22711                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
22713         }
22714         if (flags & NDR_OUT) {
22715                 if (r->out.num_written == NULL) {
22716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22717                 }
22718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
22719                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22720         }
22721         return NDR_ERR_SUCCESS;
22722 }
22723
22724 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
22725 {
22726         TALLOC_CTX *_mem_save_handle_0;
22727         TALLOC_CTX *_mem_save_num_written_0;
22728         if (flags & NDR_IN) {
22729                 ZERO_STRUCT(r->out);
22730
22731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22732                         NDR_PULL_ALLOC(ndr, r->in.handle);
22733                 }
22734                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22735                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22738                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
22739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
22740                 NDR_PULL_ALLOC(ndr, r->out.num_written);
22741                 ZERO_STRUCTP(r->out.num_written);
22742         }
22743         if (flags & NDR_OUT) {
22744                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22745                         NDR_PULL_ALLOC(ndr, r->out.num_written);
22746                 }
22747                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
22748                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
22749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
22750                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
22751                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22752         }
22753         return NDR_ERR_SUCCESS;
22754 }
22755
22756 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
22757 {
22758         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
22759         ndr->depth++;
22760         if (flags & NDR_SET_VALUES) {
22761                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22762         }
22763         if (flags & NDR_IN) {
22764                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
22765                 ndr->depth++;
22766                 ndr_print_ptr(ndr, "handle", r->in.handle);
22767                 ndr->depth++;
22768                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22769                 ndr->depth--;
22770                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
22771                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
22772                 ndr->depth--;
22773         }
22774         if (flags & NDR_OUT) {
22775                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
22776                 ndr->depth++;
22777                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
22778                 ndr->depth++;
22779                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
22780                 ndr->depth--;
22781                 ndr_print_WERROR(ndr, "result", r->out.result);
22782                 ndr->depth--;
22783         }
22784         ndr->depth--;
22785 }
22786
22787 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22788 {
22789         if (flags & NDR_IN) {
22790                 if (r->in.handle == NULL) {
22791                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22792                 }
22793                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22794         }
22795         if (flags & NDR_OUT) {
22796                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22797         }
22798         return NDR_ERR_SUCCESS;
22799 }
22800
22801 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22802 {
22803         TALLOC_CTX *_mem_save_handle_0;
22804         if (flags & NDR_IN) {
22805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22806                         NDR_PULL_ALLOC(ndr, r->in.handle);
22807                 }
22808                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22809                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22810                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22812         }
22813         if (flags & NDR_OUT) {
22814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22815         }
22816         return NDR_ERR_SUCCESS;
22817 }
22818
22819 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22820 {
22821         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22822         ndr->depth++;
22823         if (flags & NDR_SET_VALUES) {
22824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22825         }
22826         if (flags & NDR_IN) {
22827                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22828                 ndr->depth++;
22829                 ndr_print_ptr(ndr, "handle", r->in.handle);
22830                 ndr->depth++;
22831                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22832                 ndr->depth--;
22833                 ndr->depth--;
22834         }
22835         if (flags & NDR_OUT) {
22836                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22837                 ndr->depth++;
22838                 ndr_print_WERROR(ndr, "result", r->out.result);
22839                 ndr->depth--;
22840         }
22841         ndr->depth--;
22842 }
22843
22844 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22845 {
22846         if (flags & NDR_IN) {
22847                 if (r->in.handle == NULL) {
22848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22849                 }
22850                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22851         }
22852         if (flags & NDR_OUT) {
22853                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22854         }
22855         return NDR_ERR_SUCCESS;
22856 }
22857
22858 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
22859 {
22860         TALLOC_CTX *_mem_save_handle_0;
22861         if (flags & NDR_IN) {
22862                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22863                         NDR_PULL_ALLOC(ndr, r->in.handle);
22864                 }
22865                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22866                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22867                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22868                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22869         }
22870         if (flags & NDR_OUT) {
22871                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22872         }
22873         return NDR_ERR_SUCCESS;
22874 }
22875
22876 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
22877 {
22878         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
22879         ndr->depth++;
22880         if (flags & NDR_SET_VALUES) {
22881                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22882         }
22883         if (flags & NDR_IN) {
22884                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
22885                 ndr->depth++;
22886                 ndr_print_ptr(ndr, "handle", r->in.handle);
22887                 ndr->depth++;
22888                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22889                 ndr->depth--;
22890                 ndr->depth--;
22891         }
22892         if (flags & NDR_OUT) {
22893                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
22894                 ndr->depth++;
22895                 ndr_print_WERROR(ndr, "result", r->out.result);
22896                 ndr->depth--;
22897         }
22898         ndr->depth--;
22899 }
22900
22901 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
22902 {
22903         if (flags & NDR_IN) {
22904                 if (r->in.handle == NULL) {
22905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22906                 }
22907                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22909         }
22910         if (flags & NDR_OUT) {
22911                 if (r->out.data == NULL) {
22912                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22913                 }
22914                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
22915                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
22916                 if (r->out._data_size == NULL) {
22917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22918                 }
22919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
22920                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22921         }
22922         return NDR_ERR_SUCCESS;
22923 }
22924
22925 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
22926 {
22927         TALLOC_CTX *_mem_save_handle_0;
22928         TALLOC_CTX *_mem_save__data_size_0;
22929         if (flags & NDR_IN) {
22930                 ZERO_STRUCT(r->out);
22931
22932                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22933                         NDR_PULL_ALLOC(ndr, r->in.handle);
22934                 }
22935                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22936                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22937                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22938                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
22940                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
22941                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
22942                 NDR_PULL_ALLOC(ndr, r->out._data_size);
22943                 ZERO_STRUCTP(r->out._data_size);
22944         }
22945         if (flags & NDR_OUT) {
22946                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
22947                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22948                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
22949                 }
22950                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
22951                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22952                         NDR_PULL_ALLOC(ndr, r->out._data_size);
22953                 }
22954                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
22955                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
22956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
22957                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
22958                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22959                 if (r->out.data) {
22960                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
22961                 }
22962         }
22963         return NDR_ERR_SUCCESS;
22964 }
22965
22966 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
22967 {
22968         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
22969         ndr->depth++;
22970         if (flags & NDR_SET_VALUES) {
22971                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22972         }
22973         if (flags & NDR_IN) {
22974                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
22975                 ndr->depth++;
22976                 ndr_print_ptr(ndr, "handle", r->in.handle);
22977                 ndr->depth++;
22978                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22979                 ndr->depth--;
22980                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
22981                 ndr->depth--;
22982         }
22983         if (flags & NDR_OUT) {
22984                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
22985                 ndr->depth++;
22986                 ndr_print_ptr(ndr, "data", r->out.data);
22987                 ndr->depth++;
22988                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
22989                 ndr->depth--;
22990                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
22991                 ndr->depth++;
22992                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
22993                 ndr->depth--;
22994                 ndr_print_WERROR(ndr, "result", r->out.result);
22995                 ndr->depth--;
22996         }
22997         ndr->depth--;
22998 }
22999
23000 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23001 {
23002         if (flags & NDR_IN) {
23003                 if (r->in.handle == NULL) {
23004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23005                 }
23006                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23007         }
23008         if (flags & NDR_OUT) {
23009                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23010         }
23011         return NDR_ERR_SUCCESS;
23012 }
23013
23014 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23015 {
23016         TALLOC_CTX *_mem_save_handle_0;
23017         if (flags & NDR_IN) {
23018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23019                         NDR_PULL_ALLOC(ndr, r->in.handle);
23020                 }
23021                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23022                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23023                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23025         }
23026         if (flags & NDR_OUT) {
23027                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23028         }
23029         return NDR_ERR_SUCCESS;
23030 }
23031
23032 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23033 {
23034         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23035         ndr->depth++;
23036         if (flags & NDR_SET_VALUES) {
23037                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23038         }
23039         if (flags & NDR_IN) {
23040                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23041                 ndr->depth++;
23042                 ndr_print_ptr(ndr, "handle", r->in.handle);
23043                 ndr->depth++;
23044                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23045                 ndr->depth--;
23046                 ndr->depth--;
23047         }
23048         if (flags & NDR_OUT) {
23049                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23050                 ndr->depth++;
23051                 ndr_print_WERROR(ndr, "result", r->out.result);
23052                 ndr->depth--;
23053         }
23054         ndr->depth--;
23055 }
23056
23057 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23058 {
23059         if (flags & NDR_IN) {
23060                 if (r->in.handle == NULL) {
23061                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23062                 }
23063                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23066                 if (r->in.buffer) {
23067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23068                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23069                 }
23070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23071         }
23072         if (flags & NDR_OUT) {
23073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23074                 if (r->out.buffer) {
23075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23076                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23077                 }
23078                 if (r->out.needed == NULL) {
23079                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23080                 }
23081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23082                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23083         }
23084         return NDR_ERR_SUCCESS;
23085 }
23086
23087 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23088 {
23089         uint32_t _ptr_buffer;
23090         TALLOC_CTX *_mem_save_handle_0;
23091         TALLOC_CTX *_mem_save_buffer_0;
23092         TALLOC_CTX *_mem_save_needed_0;
23093         if (flags & NDR_IN) {
23094                 ZERO_STRUCT(r->out);
23095
23096                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23097                         NDR_PULL_ALLOC(ndr, r->in.handle);
23098                 }
23099                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23100                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23101                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23105                 if (_ptr_buffer) {
23106                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23107                 } else {
23108                         r->in.buffer = NULL;
23109                 }
23110                 if (r->in.buffer) {
23111                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23112                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23113                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23114                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23115                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23117                 }
23118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23119                 NDR_PULL_ALLOC(ndr, r->out.needed);
23120                 ZERO_STRUCTP(r->out.needed);
23121                 if (r->in.buffer) {
23122                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23123                 }
23124         }
23125         if (flags & NDR_OUT) {
23126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23127                 if (_ptr_buffer) {
23128                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23129                 } else {
23130                         r->out.buffer = NULL;
23131                 }
23132                 if (r->out.buffer) {
23133                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23134                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23135                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23136                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23137                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23139                 }
23140                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23141                         NDR_PULL_ALLOC(ndr, r->out.needed);
23142                 }
23143                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23144                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23146                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23147                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23148                 if (r->out.buffer) {
23149                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23150                 }
23151         }
23152         return NDR_ERR_SUCCESS;
23153 }
23154
23155 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23156 {
23157         ndr_print_struct(ndr, name, "spoolss_AddJob");
23158         ndr->depth++;
23159         if (flags & NDR_SET_VALUES) {
23160                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23161         }
23162         if (flags & NDR_IN) {
23163                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23164                 ndr->depth++;
23165                 ndr_print_ptr(ndr, "handle", r->in.handle);
23166                 ndr->depth++;
23167                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23168                 ndr->depth--;
23169                 ndr_print_uint32(ndr, "level", r->in.level);
23170                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23171                 ndr->depth++;
23172                 if (r->in.buffer) {
23173                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23174                 }
23175                 ndr->depth--;
23176                 ndr_print_uint32(ndr, "offered", r->in.offered);
23177                 ndr->depth--;
23178         }
23179         if (flags & NDR_OUT) {
23180                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23181                 ndr->depth++;
23182                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23183                 ndr->depth++;
23184                 if (r->out.buffer) {
23185                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23186                 }
23187                 ndr->depth--;
23188                 ndr_print_ptr(ndr, "needed", r->out.needed);
23189                 ndr->depth++;
23190                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23191                 ndr->depth--;
23192                 ndr_print_WERROR(ndr, "result", r->out.result);
23193                 ndr->depth--;
23194         }
23195         ndr->depth--;
23196 }
23197
23198 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23199 {
23200         if (flags & NDR_IN) {
23201                 if (r->in.handle == NULL) {
23202                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23203                 }
23204                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23206         }
23207         if (flags & NDR_OUT) {
23208                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23209         }
23210         return NDR_ERR_SUCCESS;
23211 }
23212
23213 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23214 {
23215         TALLOC_CTX *_mem_save_handle_0;
23216         if (flags & NDR_IN) {
23217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23218                         NDR_PULL_ALLOC(ndr, r->in.handle);
23219                 }
23220                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23221                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23222                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23225         }
23226         if (flags & NDR_OUT) {
23227                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23228         }
23229         return NDR_ERR_SUCCESS;
23230 }
23231
23232 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23233 {
23234         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23235         ndr->depth++;
23236         if (flags & NDR_SET_VALUES) {
23237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23238         }
23239         if (flags & NDR_IN) {
23240                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23241                 ndr->depth++;
23242                 ndr_print_ptr(ndr, "handle", r->in.handle);
23243                 ndr->depth++;
23244                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23245                 ndr->depth--;
23246                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23247                 ndr->depth--;
23248         }
23249         if (flags & NDR_OUT) {
23250                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23251                 ndr->depth++;
23252                 ndr_print_WERROR(ndr, "result", r->out.result);
23253                 ndr->depth--;
23254         }
23255         ndr->depth--;
23256 }
23257
23258 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
23259 {
23260         if (flags & NDR_IN) {
23261                 if (r->in.handle == NULL) {
23262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23263                 }
23264                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23265                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23266                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23267                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23268                 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));
23269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23270         }
23271         if (flags & NDR_OUT) {
23272                 if (r->out.type == NULL) {
23273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23274                 }
23275                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23276                 if (r->out.data == NULL) {
23277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23278                 }
23279                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
23280                 if (r->out.needed == NULL) {
23281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23282                 }
23283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23284                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23285         }
23286         return NDR_ERR_SUCCESS;
23287 }
23288
23289 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
23290 {
23291         TALLOC_CTX *_mem_save_handle_0;
23292         TALLOC_CTX *_mem_save_type_0;
23293         TALLOC_CTX *_mem_save_data_0;
23294         TALLOC_CTX *_mem_save_needed_0;
23295         if (flags & NDR_IN) {
23296                 ZERO_STRUCT(r->out);
23297
23298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23299                         NDR_PULL_ALLOC(ndr, r->in.handle);
23300                 }
23301                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23303                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23305                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23306                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23307                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23308                         return 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));
23309                 }
23310                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23311                 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));
23312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23313                 NDR_PULL_ALLOC(ndr, r->out.type);
23314                 ZERO_STRUCTP(r->out.type);
23315                 NDR_PULL_ALLOC(ndr, r->out.data);
23316                 ZERO_STRUCTP(r->out.data);
23317                 NDR_PULL_ALLOC(ndr, r->out.needed);
23318                 ZERO_STRUCTP(r->out.needed);
23319         }
23320         if (flags & NDR_OUT) {
23321                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23322                         NDR_PULL_ALLOC(ndr, r->out.type);
23323                 }
23324                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23325                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23326                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23327                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23329                         NDR_PULL_ALLOC(ndr, r->out.data);
23330                 }
23331                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23332                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23333                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23336                         NDR_PULL_ALLOC(ndr, r->out.needed);
23337                 }
23338                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23339                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23342                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23343         }
23344         return NDR_ERR_SUCCESS;
23345 }
23346
23347 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23348 {
23349         if (flags & NDR_IN) {
23350                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23351         }
23352         if (flags & NDR_OUT) {
23353                 if (r->out.data == NULL) {
23354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23355                 }
23356                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23357                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23358         }
23359         return NDR_ERR_SUCCESS;
23360 }
23361
23362 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23363 {
23364         TALLOC_CTX *_mem_save_data_0;
23365         if (flags & NDR_IN) {
23366                 ZERO_STRUCT(r->out);
23367
23368                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23369                 NDR_PULL_ALLOC(ndr, r->out.data);
23370                 ZERO_STRUCTP(r->out.data);
23371         }
23372         if (flags & NDR_OUT) {
23373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23374                         NDR_PULL_ALLOC(ndr, r->out.data);
23375                 }
23376                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23377                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23378                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23379                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23381         }
23382         return NDR_ERR_SUCCESS;
23383 }
23384
23385 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23386 {
23387         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23388         ndr->depth++;
23389         if (flags & NDR_SET_VALUES) {
23390                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23391         }
23392         if (flags & NDR_IN) {
23393                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23394                 ndr->depth++;
23395                 ndr_print_ptr(ndr, "handle", r->in.handle);
23396                 ndr->depth++;
23397                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23398                 ndr->depth--;
23399                 ndr_print_string(ndr, "value_name", r->in.value_name);
23400                 ndr_print_uint32(ndr, "offered", r->in.offered);
23401                 ndr->depth--;
23402         }
23403         if (flags & NDR_OUT) {
23404                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23405                 ndr->depth++;
23406                 ndr_print_ptr(ndr, "type", r->out.type);
23407                 ndr->depth++;
23408                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23409                 ndr->depth--;
23410                 ndr_print_ptr(ndr, "data", r->out.data);
23411                 ndr->depth++;
23412                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23413                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23414                 ndr->depth--;
23415                 ndr_print_ptr(ndr, "needed", r->out.needed);
23416                 ndr->depth++;
23417                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23418                 ndr->depth--;
23419                 ndr_print_WERROR(ndr, "result", r->out.result);
23420                 ndr->depth--;
23421         }
23422         ndr->depth--;
23423 }
23424
23425 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23426 {
23427         if (flags & NDR_IN) {
23428                 if (r->in.handle == NULL) {
23429                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23430                 }
23431                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23432                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23433                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23434                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23435                 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));
23436                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23437                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
23439         }
23440         if (flags & NDR_OUT) {
23441                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23442         }
23443         return NDR_ERR_SUCCESS;
23444 }
23445
23446 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
23447 {
23448         if (flags & NDR_IN) {
23449                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23450         }
23451         if (flags & NDR_OUT) {
23452                 if (r->out.data == NULL) {
23453                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23454                 }
23455                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23456                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23457         }
23458         return NDR_ERR_SUCCESS;
23459 }
23460
23461 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23462 {
23463         TALLOC_CTX *_mem_save_handle_0;
23464         if (flags & NDR_IN) {
23465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23466                         NDR_PULL_ALLOC(ndr, r->in.handle);
23467                 }
23468                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23469                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23470                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23472                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23473                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23474                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23475                         return 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));
23476                 }
23477                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23478                 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));
23479                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23480                 {
23481                         struct ndr_pull *_ndr_data;
23482                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
23483                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
23484                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
23485                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
23486                 }
23487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
23488         }
23489         if (flags & NDR_OUT) {
23490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23491         }
23492         return NDR_ERR_SUCCESS;
23493 }
23494
23495 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23496 {
23497         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
23498         ndr->depth++;
23499         if (flags & NDR_SET_VALUES) {
23500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23501         }
23502         if (flags & NDR_IN) {
23503                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
23504                 ndr->depth++;
23505                 ndr_print_ptr(ndr, "handle", r->in.handle);
23506                 ndr->depth++;
23507                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23508                 ndr->depth--;
23509                 ndr_print_string(ndr, "value_name", r->in.value_name);
23510                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23511                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
23512                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
23513                 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);
23514                 ndr->depth--;
23515         }
23516         if (flags & NDR_OUT) {
23517                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23518                 ndr->depth++;
23519                 ndr_print_WERROR(ndr, "result", r->out.result);
23520                 ndr->depth--;
23521         }
23522         ndr->depth--;
23523 }
23524
23525 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23526 {
23527         if (flags & NDR_IN) {
23528         }
23529         if (flags & NDR_OUT) {
23530                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23531         }
23532         return NDR_ERR_SUCCESS;
23533 }
23534
23535 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23536 {
23537         if (flags & NDR_IN) {
23538         }
23539         if (flags & NDR_OUT) {
23540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23541         }
23542         return NDR_ERR_SUCCESS;
23543 }
23544
23545 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
23546 {
23547         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
23548         ndr->depth++;
23549         if (flags & NDR_SET_VALUES) {
23550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23551         }
23552         if (flags & NDR_IN) {
23553                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
23554                 ndr->depth++;
23555                 ndr->depth--;
23556         }
23557         if (flags & NDR_OUT) {
23558                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
23559                 ndr->depth++;
23560                 ndr_print_WERROR(ndr, "result", r->out.result);
23561                 ndr->depth--;
23562         }
23563         ndr->depth--;
23564 }
23565
23566 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
23567 {
23568         if (flags & NDR_IN) {
23569                 if (r->in.handle == NULL) {
23570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23571                 }
23572                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23573         }
23574         if (flags & NDR_OUT) {
23575                 if (r->out.handle == NULL) {
23576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23577                 }
23578                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23580         }
23581         return NDR_ERR_SUCCESS;
23582 }
23583
23584 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23585 {
23586         TALLOC_CTX *_mem_save_handle_0;
23587         if (flags & NDR_IN) {
23588                 ZERO_STRUCT(r->out);
23589
23590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23591                         NDR_PULL_ALLOC(ndr, r->in.handle);
23592                 }
23593                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23594                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23595                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23597                 NDR_PULL_ALLOC(ndr, r->out.handle);
23598                 *r->out.handle = *r->in.handle;
23599         }
23600         if (flags & NDR_OUT) {
23601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23602                         NDR_PULL_ALLOC(ndr, r->out.handle);
23603                 }
23604                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23605                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23606                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23608                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23609         }
23610         return NDR_ERR_SUCCESS;
23611 }
23612
23613 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23614 {
23615         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23616         ndr->depth++;
23617         if (flags & NDR_SET_VALUES) {
23618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23619         }
23620         if (flags & NDR_IN) {
23621                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23622                 ndr->depth++;
23623                 ndr_print_ptr(ndr, "handle", r->in.handle);
23624                 ndr->depth++;
23625                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23626                 ndr->depth--;
23627                 ndr->depth--;
23628         }
23629         if (flags & NDR_OUT) {
23630                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23631                 ndr->depth++;
23632                 ndr_print_ptr(ndr, "handle", r->out.handle);
23633                 ndr->depth++;
23634                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23635                 ndr->depth--;
23636                 ndr_print_WERROR(ndr, "result", r->out.result);
23637                 ndr->depth--;
23638         }
23639         ndr->depth--;
23640 }
23641
23642 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23643 {
23644         if (flags & NDR_IN) {
23645                 if (r->in.handle == NULL) {
23646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23647                 }
23648                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23650                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23651                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23652         }
23653         if (flags & NDR_OUT) {
23654                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23655         }
23656         return NDR_ERR_SUCCESS;
23657 }
23658
23659 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23660 {
23661         TALLOC_CTX *_mem_save_handle_0;
23662         if (flags & NDR_IN) {
23663                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23664                         NDR_PULL_ALLOC(ndr, r->in.handle);
23665                 }
23666                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23667                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23668                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23669                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23671                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23672                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23673         }
23674         if (flags & NDR_OUT) {
23675                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23676         }
23677         return NDR_ERR_SUCCESS;
23678 }
23679
23680 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23681 {
23682         ndr_print_struct(ndr, name, "spoolss_AddForm");
23683         ndr->depth++;
23684         if (flags & NDR_SET_VALUES) {
23685                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23686         }
23687         if (flags & NDR_IN) {
23688                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
23689                 ndr->depth++;
23690                 ndr_print_ptr(ndr, "handle", r->in.handle);
23691                 ndr->depth++;
23692                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23693                 ndr->depth--;
23694                 ndr_print_uint32(ndr, "level", r->in.level);
23695                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23696                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23697                 ndr->depth--;
23698         }
23699         if (flags & NDR_OUT) {
23700                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
23701                 ndr->depth++;
23702                 ndr_print_WERROR(ndr, "result", r->out.result);
23703                 ndr->depth--;
23704         }
23705         ndr->depth--;
23706 }
23707
23708 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
23709 {
23710         if (flags & NDR_IN) {
23711                 if (r->in.handle == NULL) {
23712                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23713                 }
23714                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23715                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23716                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23717                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23718                 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));
23719         }
23720         if (flags & NDR_OUT) {
23721                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23722         }
23723         return NDR_ERR_SUCCESS;
23724 }
23725
23726 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
23727 {
23728         TALLOC_CTX *_mem_save_handle_0;
23729         if (flags & NDR_IN) {
23730                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23731                         NDR_PULL_ALLOC(ndr, r->in.handle);
23732                 }
23733                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23734                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23735                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23737                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23738                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23739                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23740                         return 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));
23741                 }
23742                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23743                 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));
23744         }
23745         if (flags & NDR_OUT) {
23746                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23747         }
23748         return NDR_ERR_SUCCESS;
23749 }
23750
23751 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
23752 {
23753         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
23754         ndr->depth++;
23755         if (flags & NDR_SET_VALUES) {
23756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23757         }
23758         if (flags & NDR_IN) {
23759                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
23760                 ndr->depth++;
23761                 ndr_print_ptr(ndr, "handle", r->in.handle);
23762                 ndr->depth++;
23763                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23764                 ndr->depth--;
23765                 ndr_print_string(ndr, "form_name", r->in.form_name);
23766                 ndr->depth--;
23767         }
23768         if (flags & NDR_OUT) {
23769                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
23770                 ndr->depth++;
23771                 ndr_print_WERROR(ndr, "result", r->out.result);
23772                 ndr->depth--;
23773         }
23774         ndr->depth--;
23775 }
23776
23777 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
23778 {
23779         if (flags & NDR_IN) {
23780                 if (r->in.handle == NULL) {
23781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23782                 }
23783                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23784                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23785                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23786                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23787                 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));
23788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23790                 if (r->in.buffer) {
23791                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23792                 }
23793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23794         }
23795         if (flags & NDR_OUT) {
23796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23797                 if (r->out.info) {
23798                         {
23799                                 struct ndr_push *_ndr_info;
23800                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23801                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23802                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23803                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23804                         }
23805                 }
23806                 if (r->out.needed == NULL) {
23807                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23808                 }
23809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23810                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23811         }
23812         return NDR_ERR_SUCCESS;
23813 }
23814
23815 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23816 {
23817         uint32_t _ptr_buffer;
23818         uint32_t _ptr_info;
23819         TALLOC_CTX *_mem_save_handle_0;
23820         TALLOC_CTX *_mem_save_buffer_0;
23821         TALLOC_CTX *_mem_save_info_0;
23822         TALLOC_CTX *_mem_save_needed_0;
23823         if (flags & NDR_IN) {
23824                 ZERO_STRUCT(r->out);
23825
23826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23827                         NDR_PULL_ALLOC(ndr, r->in.handle);
23828                 }
23829                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23831                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23833                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23834                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23835                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23836                         return 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));
23837                 }
23838                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23839                 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));
23840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23842                 if (_ptr_buffer) {
23843                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23844                 } else {
23845                         r->in.buffer = NULL;
23846                 }
23847                 if (r->in.buffer) {
23848                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23849                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23850                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23852                 }
23853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23854                 NDR_PULL_ALLOC(ndr, r->out.needed);
23855                 ZERO_STRUCTP(r->out.needed);
23856         }
23857         if (flags & NDR_OUT) {
23858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23859                 if (_ptr_info) {
23860                         NDR_PULL_ALLOC(ndr, r->out.info);
23861                 } else {
23862                         r->out.info = NULL;
23863                 }
23864                 if (r->out.info) {
23865                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23866                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23867                         {
23868                                 struct ndr_pull *_ndr_info;
23869                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23870                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23871                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23872                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23873                         }
23874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23875                 }
23876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23877                         NDR_PULL_ALLOC(ndr, r->out.needed);
23878                 }
23879                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23880                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23883                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23884         }
23885         return NDR_ERR_SUCCESS;
23886 }
23887
23888 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23889 {
23890         ndr_print_struct(ndr, name, "spoolss_GetForm");
23891         ndr->depth++;
23892         if (flags & NDR_SET_VALUES) {
23893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23894         }
23895         if (flags & NDR_IN) {
23896                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
23897                 ndr->depth++;
23898                 ndr_print_ptr(ndr, "handle", r->in.handle);
23899                 ndr->depth++;
23900                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23901                 ndr->depth--;
23902                 ndr_print_string(ndr, "form_name", r->in.form_name);
23903                 ndr_print_uint32(ndr, "level", r->in.level);
23904                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23905                 ndr->depth++;
23906                 if (r->in.buffer) {
23907                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23908                 }
23909                 ndr->depth--;
23910                 ndr_print_uint32(ndr, "offered", r->in.offered);
23911                 ndr->depth--;
23912         }
23913         if (flags & NDR_OUT) {
23914                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
23915                 ndr->depth++;
23916                 ndr_print_ptr(ndr, "info", r->out.info);
23917                 ndr->depth++;
23918                 if (r->out.info) {
23919                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23920                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
23921                 }
23922                 ndr->depth--;
23923                 ndr_print_ptr(ndr, "needed", r->out.needed);
23924                 ndr->depth++;
23925                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23926                 ndr->depth--;
23927                 ndr_print_WERROR(ndr, "result", r->out.result);
23928                 ndr->depth--;
23929         }
23930         ndr->depth--;
23931 }
23932
23933 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
23934 {
23935         if (flags & NDR_IN) {
23936                 if (r->in.handle == NULL) {
23937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23938                 }
23939                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23940                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23941                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23942                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23943                 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));
23944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23945                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23946                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23947         }
23948         if (flags & NDR_OUT) {
23949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23950         }
23951         return NDR_ERR_SUCCESS;
23952 }
23953
23954 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
23955 {
23956         TALLOC_CTX *_mem_save_handle_0;
23957         if (flags & NDR_IN) {
23958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23959                         NDR_PULL_ALLOC(ndr, r->in.handle);
23960                 }
23961                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23962                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23963                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23965                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23966                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23967                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23968                         return 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));
23969                 }
23970                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23971                 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));
23972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23973                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23974                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23975         }
23976         if (flags & NDR_OUT) {
23977                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23978         }
23979         return NDR_ERR_SUCCESS;
23980 }
23981
23982 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
23983 {
23984         ndr_print_struct(ndr, name, "spoolss_SetForm");
23985         ndr->depth++;
23986         if (flags & NDR_SET_VALUES) {
23987                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23988         }
23989         if (flags & NDR_IN) {
23990                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
23991                 ndr->depth++;
23992                 ndr_print_ptr(ndr, "handle", r->in.handle);
23993                 ndr->depth++;
23994                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23995                 ndr->depth--;
23996                 ndr_print_string(ndr, "form_name", r->in.form_name);
23997                 ndr_print_uint32(ndr, "level", r->in.level);
23998                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23999                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24000                 ndr->depth--;
24001         }
24002         if (flags & NDR_OUT) {
24003                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24004                 ndr->depth++;
24005                 ndr_print_WERROR(ndr, "result", r->out.result);
24006                 ndr->depth--;
24007         }
24008         ndr->depth--;
24009 }
24010
24011 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24012 {
24013         if (flags & NDR_IN) {
24014                 if (r->in.handle == NULL) {
24015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24016                 }
24017                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24020                 if (r->in.buffer) {
24021                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24022                 }
24023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24024         }
24025         if (flags & NDR_OUT) {
24026                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24027                 if (r->out.info) {
24028                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24029                 }
24030                 if (r->out.needed == NULL) {
24031                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24032                 }
24033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24034                 if (r->out.count == NULL) {
24035                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24036                 }
24037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24038                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24039         }
24040         return NDR_ERR_SUCCESS;
24041 }
24042
24043 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24044 {
24045         uint32_t _ptr_buffer;
24046         uint32_t _ptr_info;
24047         TALLOC_CTX *_mem_save_handle_0;
24048         TALLOC_CTX *_mem_save_buffer_0;
24049         TALLOC_CTX *_mem_save_info_0;
24050         TALLOC_CTX *_mem_save_needed_0;
24051         TALLOC_CTX *_mem_save_count_0;
24052         if (flags & NDR_IN) {
24053                 ZERO_STRUCT(r->out);
24054
24055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24056                         NDR_PULL_ALLOC(ndr, r->in.handle);
24057                 }
24058                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24059                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24060                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24064                 if (_ptr_buffer) {
24065                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24066                 } else {
24067                         r->in.buffer = NULL;
24068                 }
24069                 if (r->in.buffer) {
24070                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24071                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24072                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24074                 }
24075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24076                 NDR_PULL_ALLOC(ndr, r->out.needed);
24077                 ZERO_STRUCTP(r->out.needed);
24078                 NDR_PULL_ALLOC(ndr, r->out.count);
24079                 ZERO_STRUCTP(r->out.count);
24080         }
24081         if (flags & NDR_OUT) {
24082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24083                 if (_ptr_info) {
24084                         NDR_PULL_ALLOC(ndr, r->out.info);
24085                 } else {
24086                         r->out.info = NULL;
24087                 }
24088                 if (r->out.info) {
24089                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24090                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24091                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24093                 }
24094                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24095                         NDR_PULL_ALLOC(ndr, r->out.needed);
24096                 }
24097                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24098                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24099                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24101                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24102                         NDR_PULL_ALLOC(ndr, r->out.count);
24103                 }
24104                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24105                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24108                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24109         }
24110         return NDR_ERR_SUCCESS;
24111 }
24112
24113 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24114 {
24115         uint32_t cntr_info_0;
24116         if (flags & NDR_IN) {
24117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24119         }
24120         if (flags & NDR_OUT) {
24121                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24122                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24123                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24124                 }
24125                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24126                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24127                 }
24128         }
24129         return NDR_ERR_SUCCESS;
24130 }
24131
24132 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24133 {
24134         uint32_t cntr_info_0;
24135         TALLOC_CTX *_mem_save_info_0;
24136         if (flags & NDR_IN) {
24137                 ZERO_STRUCT(r->out);
24138
24139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24141         }
24142         if (flags & NDR_OUT) {
24143                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24144                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24145                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24146                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24147                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24148                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24149                 }
24150                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24151                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24152                 }
24153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24154         }
24155         return NDR_ERR_SUCCESS;
24156 }
24157
24158 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24159 {
24160         uint32_t cntr_info_2;
24161         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24162         ndr->depth++;
24163         if (flags & NDR_SET_VALUES) {
24164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24165         }
24166         if (flags & NDR_IN) {
24167                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24168                 ndr->depth++;
24169                 ndr_print_ptr(ndr, "handle", r->in.handle);
24170                 ndr->depth++;
24171                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24172                 ndr->depth--;
24173                 ndr_print_uint32(ndr, "level", r->in.level);
24174                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24175                 ndr->depth++;
24176                 if (r->in.buffer) {
24177                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24178                 }
24179                 ndr->depth--;
24180                 ndr_print_uint32(ndr, "offered", r->in.offered);
24181                 ndr->depth--;
24182         }
24183         if (flags & NDR_OUT) {
24184                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24185                 ndr->depth++;
24186                 ndr_print_ptr(ndr, "count", r->out.count);
24187                 ndr->depth++;
24188                 ndr_print_uint32(ndr, "count", *r->out.count);
24189                 ndr->depth--;
24190                 ndr_print_ptr(ndr, "info", r->out.info);
24191                 ndr->depth++;
24192                 ndr_print_ptr(ndr, "info", *r->out.info);
24193                 ndr->depth++;
24194                 if (*r->out.info) {
24195                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24196                         ndr->depth++;
24197                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24198                                 char *idx_2=NULL;
24199                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24200                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24201                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24202                                         free(idx_2);
24203                                 }
24204                         }
24205                         ndr->depth--;
24206                 }
24207                 ndr->depth--;
24208                 ndr->depth--;
24209                 ndr_print_ptr(ndr, "needed", r->out.needed);
24210                 ndr->depth++;
24211                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24212                 ndr->depth--;
24213                 ndr_print_WERROR(ndr, "result", r->out.result);
24214                 ndr->depth--;
24215         }
24216         ndr->depth--;
24217 }
24218
24219 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24220 {
24221         if (flags & NDR_IN) {
24222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24223                 if (r->in.servername) {
24224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24228                 }
24229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24231                 if (r->in.buffer) {
24232                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24233                 }
24234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24235         }
24236         if (flags & NDR_OUT) {
24237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24238                 if (r->out.info) {
24239                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24240                 }
24241                 if (r->out.needed == NULL) {
24242                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24243                 }
24244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24245                 if (r->out.count == NULL) {
24246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24247                 }
24248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24249                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24250         }
24251         return NDR_ERR_SUCCESS;
24252 }
24253
24254 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24255 {
24256         uint32_t _ptr_servername;
24257         uint32_t _ptr_buffer;
24258         uint32_t _ptr_info;
24259         TALLOC_CTX *_mem_save_servername_0;
24260         TALLOC_CTX *_mem_save_buffer_0;
24261         TALLOC_CTX *_mem_save_info_0;
24262         TALLOC_CTX *_mem_save_needed_0;
24263         TALLOC_CTX *_mem_save_count_0;
24264         if (flags & NDR_IN) {
24265                 ZERO_STRUCT(r->out);
24266
24267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24268                 if (_ptr_servername) {
24269                         NDR_PULL_ALLOC(ndr, r->in.servername);
24270                 } else {
24271                         r->in.servername = NULL;
24272                 }
24273                 if (r->in.servername) {
24274                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24275                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24276                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24277                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24278                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24279                                 return 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));
24280                         }
24281                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24282                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24284                 }
24285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24287                 if (_ptr_buffer) {
24288                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24289                 } else {
24290                         r->in.buffer = NULL;
24291                 }
24292                 if (r->in.buffer) {
24293                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24295                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24297                 }
24298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24299                 NDR_PULL_ALLOC(ndr, r->out.needed);
24300                 ZERO_STRUCTP(r->out.needed);
24301                 NDR_PULL_ALLOC(ndr, r->out.count);
24302                 ZERO_STRUCTP(r->out.count);
24303         }
24304         if (flags & NDR_OUT) {
24305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24306                 if (_ptr_info) {
24307                         NDR_PULL_ALLOC(ndr, r->out.info);
24308                 } else {
24309                         r->out.info = NULL;
24310                 }
24311                 if (r->out.info) {
24312                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24313                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24314                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24316                 }
24317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24318                         NDR_PULL_ALLOC(ndr, r->out.needed);
24319                 }
24320                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24321                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24325                         NDR_PULL_ALLOC(ndr, r->out.count);
24326                 }
24327                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24328                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24331                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24332         }
24333         return NDR_ERR_SUCCESS;
24334 }
24335
24336 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24337 {
24338         uint32_t cntr_info_0;
24339         if (flags & NDR_IN) {
24340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24342         }
24343         if (flags & NDR_OUT) {
24344                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24345                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24346                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24347                 }
24348                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24349                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24350                 }
24351         }
24352         return NDR_ERR_SUCCESS;
24353 }
24354
24355 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24356 {
24357         uint32_t cntr_info_0;
24358         TALLOC_CTX *_mem_save_info_0;
24359         if (flags & NDR_IN) {
24360                 ZERO_STRUCT(r->out);
24361
24362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24364         }
24365         if (flags & NDR_OUT) {
24366                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24367                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24369                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24370                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24371                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24372                 }
24373                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24374                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24375                 }
24376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24377         }
24378         return NDR_ERR_SUCCESS;
24379 }
24380
24381 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24382 {
24383         uint32_t cntr_info_2;
24384         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24385         ndr->depth++;
24386         if (flags & NDR_SET_VALUES) {
24387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24388         }
24389         if (flags & NDR_IN) {
24390                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24391                 ndr->depth++;
24392                 ndr_print_ptr(ndr, "servername", r->in.servername);
24393                 ndr->depth++;
24394                 if (r->in.servername) {
24395                         ndr_print_string(ndr, "servername", r->in.servername);
24396                 }
24397                 ndr->depth--;
24398                 ndr_print_uint32(ndr, "level", r->in.level);
24399                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24400                 ndr->depth++;
24401                 if (r->in.buffer) {
24402                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24403                 }
24404                 ndr->depth--;
24405                 ndr_print_uint32(ndr, "offered", r->in.offered);
24406                 ndr->depth--;
24407         }
24408         if (flags & NDR_OUT) {
24409                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24410                 ndr->depth++;
24411                 ndr_print_ptr(ndr, "count", r->out.count);
24412                 ndr->depth++;
24413                 ndr_print_uint32(ndr, "count", *r->out.count);
24414                 ndr->depth--;
24415                 ndr_print_ptr(ndr, "info", r->out.info);
24416                 ndr->depth++;
24417                 ndr_print_ptr(ndr, "info", *r->out.info);
24418                 ndr->depth++;
24419                 if (*r->out.info) {
24420                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24421                         ndr->depth++;
24422                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24423                                 char *idx_2=NULL;
24424                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24425                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24426                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24427                                         free(idx_2);
24428                                 }
24429                         }
24430                         ndr->depth--;
24431                 }
24432                 ndr->depth--;
24433                 ndr->depth--;
24434                 ndr_print_ptr(ndr, "needed", r->out.needed);
24435                 ndr->depth++;
24436                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24437                 ndr->depth--;
24438                 ndr_print_WERROR(ndr, "result", r->out.result);
24439                 ndr->depth--;
24440         }
24441         ndr->depth--;
24442 }
24443
24444 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24445 {
24446         if (flags & NDR_IN) {
24447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24448                 if (r->in.servername) {
24449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24453                 }
24454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24455                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24456                 if (r->in.buffer) {
24457                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24458                 }
24459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24460         }
24461         if (flags & NDR_OUT) {
24462                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24463                 if (r->out.info) {
24464                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24465                 }
24466                 if (r->out.needed == NULL) {
24467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24468                 }
24469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24470                 if (r->out.count == NULL) {
24471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24472                 }
24473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24474                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24475         }
24476         return NDR_ERR_SUCCESS;
24477 }
24478
24479 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24480 {
24481         uint32_t _ptr_servername;
24482         uint32_t _ptr_buffer;
24483         uint32_t _ptr_info;
24484         TALLOC_CTX *_mem_save_servername_0;
24485         TALLOC_CTX *_mem_save_buffer_0;
24486         TALLOC_CTX *_mem_save_info_0;
24487         TALLOC_CTX *_mem_save_needed_0;
24488         TALLOC_CTX *_mem_save_count_0;
24489         if (flags & NDR_IN) {
24490                 ZERO_STRUCT(r->out);
24491
24492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24493                 if (_ptr_servername) {
24494                         NDR_PULL_ALLOC(ndr, r->in.servername);
24495                 } else {
24496                         r->in.servername = NULL;
24497                 }
24498                 if (r->in.servername) {
24499                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24500                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24501                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24502                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24503                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24504                                 return 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));
24505                         }
24506                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24507                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24509                 }
24510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24511                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24512                 if (_ptr_buffer) {
24513                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24514                 } else {
24515                         r->in.buffer = NULL;
24516                 }
24517                 if (r->in.buffer) {
24518                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24519                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24520                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24522                 }
24523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24524                 NDR_PULL_ALLOC(ndr, r->out.needed);
24525                 ZERO_STRUCTP(r->out.needed);
24526                 NDR_PULL_ALLOC(ndr, r->out.count);
24527                 ZERO_STRUCTP(r->out.count);
24528         }
24529         if (flags & NDR_OUT) {
24530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24531                 if (_ptr_info) {
24532                         NDR_PULL_ALLOC(ndr, r->out.info);
24533                 } else {
24534                         r->out.info = NULL;
24535                 }
24536                 if (r->out.info) {
24537                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24538                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24539                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24541                 }
24542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24543                         NDR_PULL_ALLOC(ndr, r->out.needed);
24544                 }
24545                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24546                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24550                         NDR_PULL_ALLOC(ndr, r->out.count);
24551                 }
24552                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24553                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24557         }
24558         return NDR_ERR_SUCCESS;
24559 }
24560
24561 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
24562 {
24563         uint32_t cntr_info_0;
24564         if (flags & NDR_IN) {
24565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24567         }
24568         if (flags & NDR_OUT) {
24569                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24570                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24571                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24572                 }
24573                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24574                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24575                 }
24576         }
24577         return NDR_ERR_SUCCESS;
24578 }
24579
24580 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24581 {
24582         uint32_t cntr_info_0;
24583         TALLOC_CTX *_mem_save_info_0;
24584         if (flags & NDR_IN) {
24585                 ZERO_STRUCT(r->out);
24586
24587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24589         }
24590         if (flags & NDR_OUT) {
24591                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24592                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24593                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24594                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24595                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24596                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24597                 }
24598                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24599                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24600                 }
24601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24602         }
24603         return NDR_ERR_SUCCESS;
24604 }
24605
24606 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24607 {
24608         uint32_t cntr_info_2;
24609         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24610         ndr->depth++;
24611         if (flags & NDR_SET_VALUES) {
24612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24613         }
24614         if (flags & NDR_IN) {
24615                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24616                 ndr->depth++;
24617                 ndr_print_ptr(ndr, "servername", r->in.servername);
24618                 ndr->depth++;
24619                 if (r->in.servername) {
24620                         ndr_print_string(ndr, "servername", r->in.servername);
24621                 }
24622                 ndr->depth--;
24623                 ndr_print_uint32(ndr, "level", r->in.level);
24624                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24625                 ndr->depth++;
24626                 if (r->in.buffer) {
24627                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24628                 }
24629                 ndr->depth--;
24630                 ndr_print_uint32(ndr, "offered", r->in.offered);
24631                 ndr->depth--;
24632         }
24633         if (flags & NDR_OUT) {
24634                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24635                 ndr->depth++;
24636                 ndr_print_ptr(ndr, "count", r->out.count);
24637                 ndr->depth++;
24638                 ndr_print_uint32(ndr, "count", *r->out.count);
24639                 ndr->depth--;
24640                 ndr_print_ptr(ndr, "info", r->out.info);
24641                 ndr->depth++;
24642                 ndr_print_ptr(ndr, "info", *r->out.info);
24643                 ndr->depth++;
24644                 if (*r->out.info) {
24645                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24646                         ndr->depth++;
24647                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24648                                 char *idx_2=NULL;
24649                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24650                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24651                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24652                                         free(idx_2);
24653                                 }
24654                         }
24655                         ndr->depth--;
24656                 }
24657                 ndr->depth--;
24658                 ndr->depth--;
24659                 ndr_print_ptr(ndr, "needed", r->out.needed);
24660                 ndr->depth++;
24661                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24662                 ndr->depth--;
24663                 ndr_print_WERROR(ndr, "result", r->out.result);
24664                 ndr->depth--;
24665         }
24666         ndr->depth--;
24667 }
24668
24669 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24670 {
24671         if (flags & NDR_IN) {
24672                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24673                 if (r->in.server_name) {
24674                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24675                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24676                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24677                         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));
24678                 }
24679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24680                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24681                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24682                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24683                 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));
24684         }
24685         if (flags & NDR_OUT) {
24686                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24687         }
24688         return NDR_ERR_SUCCESS;
24689 }
24690
24691 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
24692 {
24693         uint32_t _ptr_server_name;
24694         TALLOC_CTX *_mem_save_server_name_0;
24695         if (flags & NDR_IN) {
24696                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
24697                 if (_ptr_server_name) {
24698                         NDR_PULL_ALLOC(ndr, r->in.server_name);
24699                 } else {
24700                         r->in.server_name = NULL;
24701                 }
24702                 if (r->in.server_name) {
24703                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24704                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
24705                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24706                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24707                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24708                                 return 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));
24709                         }
24710                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24711                         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));
24712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
24713                 }
24714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
24715                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
24716                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
24717                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
24718                         return 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));
24719                 }
24720                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
24721                 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));
24722         }
24723         if (flags & NDR_OUT) {
24724                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24725         }
24726         return NDR_ERR_SUCCESS;
24727 }
24728
24729 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
24730 {
24731         ndr_print_struct(ndr, name, "spoolss_AddPort");
24732         ndr->depth++;
24733         if (flags & NDR_SET_VALUES) {
24734                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24735         }
24736         if (flags & NDR_IN) {
24737                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
24738                 ndr->depth++;
24739                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
24740                 ndr->depth++;
24741                 if (r->in.server_name) {
24742                         ndr_print_string(ndr, "server_name", r->in.server_name);
24743                 }
24744                 ndr->depth--;
24745                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
24746                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
24747                 ndr->depth--;
24748         }
24749         if (flags & NDR_OUT) {
24750                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
24751                 ndr->depth++;
24752                 ndr_print_WERROR(ndr, "result", r->out.result);
24753                 ndr->depth--;
24754         }
24755         ndr->depth--;
24756 }
24757
24758 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
24759 {
24760         if (flags & NDR_IN) {
24761         }
24762         if (flags & NDR_OUT) {
24763                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24764         }
24765         return NDR_ERR_SUCCESS;
24766 }
24767
24768 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
24769 {
24770         if (flags & NDR_IN) {
24771         }
24772         if (flags & NDR_OUT) {
24773                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24774         }
24775         return NDR_ERR_SUCCESS;
24776 }
24777
24778 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
24779 {
24780         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
24781         ndr->depth++;
24782         if (flags & NDR_SET_VALUES) {
24783                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24784         }
24785         if (flags & NDR_IN) {
24786                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24787                 ndr->depth++;
24788                 ndr->depth--;
24789         }
24790         if (flags & NDR_OUT) {
24791                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24792                 ndr->depth++;
24793                 ndr_print_WERROR(ndr, "result", r->out.result);
24794                 ndr->depth--;
24795         }
24796         ndr->depth--;
24797 }
24798
24799 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24800 {
24801         if (flags & NDR_IN) {
24802         }
24803         if (flags & NDR_OUT) {
24804                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24805         }
24806         return NDR_ERR_SUCCESS;
24807 }
24808
24809 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24810 {
24811         if (flags & NDR_IN) {
24812         }
24813         if (flags & NDR_OUT) {
24814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24815         }
24816         return NDR_ERR_SUCCESS;
24817 }
24818
24819 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24820 {
24821         ndr_print_struct(ndr, name, "spoolss_DeletePort");
24822         ndr->depth++;
24823         if (flags & NDR_SET_VALUES) {
24824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24825         }
24826         if (flags & NDR_IN) {
24827                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24828                 ndr->depth++;
24829                 ndr->depth--;
24830         }
24831         if (flags & NDR_OUT) {
24832                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24833                 ndr->depth++;
24834                 ndr_print_WERROR(ndr, "result", r->out.result);
24835                 ndr->depth--;
24836         }
24837         ndr->depth--;
24838 }
24839
24840 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24841 {
24842         if (flags & NDR_IN) {
24843                 if (r->in.handle == NULL) {
24844                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24845                 }
24846                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24847                 if (r->in.devmode_ctr == NULL) {
24848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24849                 }
24850                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24851         }
24852         if (flags & NDR_OUT) {
24853                 if (r->out.gdi_handle == NULL) {
24854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24855                 }
24856                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24857                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24858         }
24859         return NDR_ERR_SUCCESS;
24860 }
24861
24862 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24863 {
24864         TALLOC_CTX *_mem_save_handle_0;
24865         TALLOC_CTX *_mem_save_gdi_handle_0;
24866         TALLOC_CTX *_mem_save_devmode_ctr_0;
24867         if (flags & NDR_IN) {
24868                 ZERO_STRUCT(r->out);
24869
24870                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24871                         NDR_PULL_ALLOC(ndr, r->in.handle);
24872                 }
24873                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24874                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24875                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24876                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24877                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24878                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24879                 }
24880                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24881                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24882                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24884                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24885                 ZERO_STRUCTP(r->out.gdi_handle);
24886         }
24887         if (flags & NDR_OUT) {
24888                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24889                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24890                 }
24891                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24892                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24893                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24894                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24895                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24896         }
24897         return NDR_ERR_SUCCESS;
24898 }
24899
24900 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
24901 {
24902         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
24903         ndr->depth++;
24904         if (flags & NDR_SET_VALUES) {
24905                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24906         }
24907         if (flags & NDR_IN) {
24908                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
24909                 ndr->depth++;
24910                 ndr_print_ptr(ndr, "handle", r->in.handle);
24911                 ndr->depth++;
24912                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24913                 ndr->depth--;
24914                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24915                 ndr->depth++;
24916                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24917                 ndr->depth--;
24918                 ndr->depth--;
24919         }
24920         if (flags & NDR_OUT) {
24921                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
24922                 ndr->depth++;
24923                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24924                 ndr->depth++;
24925                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24926                 ndr->depth--;
24927                 ndr_print_WERROR(ndr, "result", r->out.result);
24928                 ndr->depth--;
24929         }
24930         ndr->depth--;
24931 }
24932
24933 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24934 {
24935         if (flags & NDR_IN) {
24936         }
24937         if (flags & NDR_OUT) {
24938                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24939         }
24940         return NDR_ERR_SUCCESS;
24941 }
24942
24943 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
24944 {
24945         if (flags & NDR_IN) {
24946         }
24947         if (flags & NDR_OUT) {
24948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24949         }
24950         return NDR_ERR_SUCCESS;
24951 }
24952
24953 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24954 {
24955         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
24956         ndr->depth++;
24957         if (flags & NDR_SET_VALUES) {
24958                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24959         }
24960         if (flags & NDR_IN) {
24961                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
24962                 ndr->depth++;
24963                 ndr->depth--;
24964         }
24965         if (flags & NDR_OUT) {
24966                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
24967                 ndr->depth++;
24968                 ndr_print_WERROR(ndr, "result", r->out.result);
24969                 ndr->depth--;
24970         }
24971         ndr->depth--;
24972 }
24973
24974 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
24975 {
24976         if (flags & NDR_IN) {
24977                 if (r->in.gdi_handle == NULL) {
24978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24979                 }
24980                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24981         }
24982         if (flags & NDR_OUT) {
24983                 if (r->out.gdi_handle == NULL) {
24984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24985                 }
24986                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24987                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24988         }
24989         return NDR_ERR_SUCCESS;
24990 }
24991
24992 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
24993 {
24994         TALLOC_CTX *_mem_save_gdi_handle_0;
24995         if (flags & NDR_IN) {
24996                 ZERO_STRUCT(r->out);
24997
24998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24999                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25000                 }
25001                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25002                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25003                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25004                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25005                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25006                 *r->out.gdi_handle = *r->in.gdi_handle;
25007         }
25008         if (flags & NDR_OUT) {
25009                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25010                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25011                 }
25012                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25013                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25014                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25016                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25017         }
25018         return NDR_ERR_SUCCESS;
25019 }
25020
25021 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25022 {
25023         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25024         ndr->depth++;
25025         if (flags & NDR_SET_VALUES) {
25026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25027         }
25028         if (flags & NDR_IN) {
25029                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25030                 ndr->depth++;
25031                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25032                 ndr->depth++;
25033                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25034                 ndr->depth--;
25035                 ndr->depth--;
25036         }
25037         if (flags & NDR_OUT) {
25038                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25039                 ndr->depth++;
25040                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25041                 ndr->depth++;
25042                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25043                 ndr->depth--;
25044                 ndr_print_WERROR(ndr, "result", r->out.result);
25045                 ndr->depth--;
25046         }
25047         ndr->depth--;
25048 }
25049
25050 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25051 {
25052         if (flags & NDR_IN) {
25053         }
25054         if (flags & NDR_OUT) {
25055                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25056         }
25057         return NDR_ERR_SUCCESS;
25058 }
25059
25060 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25061 {
25062         if (flags & NDR_IN) {
25063         }
25064         if (flags & NDR_OUT) {
25065                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25066         }
25067         return NDR_ERR_SUCCESS;
25068 }
25069
25070 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25071 {
25072         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25073         ndr->depth++;
25074         if (flags & NDR_SET_VALUES) {
25075                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25076         }
25077         if (flags & NDR_IN) {
25078                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25079                 ndr->depth++;
25080                 ndr->depth--;
25081         }
25082         if (flags & NDR_OUT) {
25083                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25084                 ndr->depth++;
25085                 ndr_print_WERROR(ndr, "result", r->out.result);
25086                 ndr->depth--;
25087         }
25088         ndr->depth--;
25089 }
25090
25091 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25092 {
25093         if (flags & NDR_IN) {
25094         }
25095         if (flags & NDR_OUT) {
25096                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25097         }
25098         return NDR_ERR_SUCCESS;
25099 }
25100
25101 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25102 {
25103         if (flags & NDR_IN) {
25104         }
25105         if (flags & NDR_OUT) {
25106                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25107         }
25108         return NDR_ERR_SUCCESS;
25109 }
25110
25111 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25112 {
25113         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25114         ndr->depth++;
25115         if (flags & NDR_SET_VALUES) {
25116                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25117         }
25118         if (flags & NDR_IN) {
25119                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25120                 ndr->depth++;
25121                 ndr->depth--;
25122         }
25123         if (flags & NDR_OUT) {
25124                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25125                 ndr->depth++;
25126                 ndr_print_WERROR(ndr, "result", r->out.result);
25127                 ndr->depth--;
25128         }
25129         ndr->depth--;
25130 }
25131
25132 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25133 {
25134         if (flags & NDR_IN) {
25135         }
25136         if (flags & NDR_OUT) {
25137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25138         }
25139         return NDR_ERR_SUCCESS;
25140 }
25141
25142 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25143 {
25144         if (flags & NDR_IN) {
25145         }
25146         if (flags & NDR_OUT) {
25147                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25148         }
25149         return NDR_ERR_SUCCESS;
25150 }
25151
25152 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25153 {
25154         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25155         ndr->depth++;
25156         if (flags & NDR_SET_VALUES) {
25157                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25158         }
25159         if (flags & NDR_IN) {
25160                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25161                 ndr->depth++;
25162                 ndr->depth--;
25163         }
25164         if (flags & NDR_OUT) {
25165                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25166                 ndr->depth++;
25167                 ndr_print_WERROR(ndr, "result", r->out.result);
25168                 ndr->depth--;
25169         }
25170         ndr->depth--;
25171 }
25172
25173 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25174 {
25175         if (flags & NDR_IN) {
25176         }
25177         if (flags & NDR_OUT) {
25178                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25179         }
25180         return NDR_ERR_SUCCESS;
25181 }
25182
25183 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25184 {
25185         if (flags & NDR_IN) {
25186         }
25187         if (flags & NDR_OUT) {
25188                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25189         }
25190         return NDR_ERR_SUCCESS;
25191 }
25192
25193 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25194 {
25195         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25196         ndr->depth++;
25197         if (flags & NDR_SET_VALUES) {
25198                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25199         }
25200         if (flags & NDR_IN) {
25201                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25202                 ndr->depth++;
25203                 ndr->depth--;
25204         }
25205         if (flags & NDR_OUT) {
25206                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25207                 ndr->depth++;
25208                 ndr_print_WERROR(ndr, "result", r->out.result);
25209                 ndr->depth--;
25210         }
25211         ndr->depth--;
25212 }
25213
25214 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25215 {
25216         if (flags & NDR_IN) {
25217         }
25218         if (flags & NDR_OUT) {
25219                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25220         }
25221         return NDR_ERR_SUCCESS;
25222 }
25223
25224 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25225 {
25226         if (flags & NDR_IN) {
25227         }
25228         if (flags & NDR_OUT) {
25229                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25230         }
25231         return NDR_ERR_SUCCESS;
25232 }
25233
25234 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25235 {
25236         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25237         ndr->depth++;
25238         if (flags & NDR_SET_VALUES) {
25239                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25240         }
25241         if (flags & NDR_IN) {
25242                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25243                 ndr->depth++;
25244                 ndr->depth--;
25245         }
25246         if (flags & NDR_OUT) {
25247                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25248                 ndr->depth++;
25249                 ndr_print_WERROR(ndr, "result", r->out.result);
25250                 ndr->depth--;
25251         }
25252         ndr->depth--;
25253 }
25254
25255 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25256 {
25257         if (flags & NDR_IN) {
25258         }
25259         if (flags & NDR_OUT) {
25260                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25261         }
25262         return NDR_ERR_SUCCESS;
25263 }
25264
25265 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25266 {
25267         if (flags & NDR_IN) {
25268         }
25269         if (flags & NDR_OUT) {
25270                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25271         }
25272         return NDR_ERR_SUCCESS;
25273 }
25274
25275 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25276 {
25277         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25278         ndr->depth++;
25279         if (flags & NDR_SET_VALUES) {
25280                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25281         }
25282         if (flags & NDR_IN) {
25283                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25284                 ndr->depth++;
25285                 ndr->depth--;
25286         }
25287         if (flags & NDR_OUT) {
25288                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25289                 ndr->depth++;
25290                 ndr_print_WERROR(ndr, "result", r->out.result);
25291                 ndr->depth--;
25292         }
25293         ndr->depth--;
25294 }
25295
25296 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25297 {
25298         if (flags & NDR_IN) {
25299         }
25300         if (flags & NDR_OUT) {
25301                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25302         }
25303         return NDR_ERR_SUCCESS;
25304 }
25305
25306 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25307 {
25308         if (flags & NDR_IN) {
25309         }
25310         if (flags & NDR_OUT) {
25311                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25312         }
25313         return NDR_ERR_SUCCESS;
25314 }
25315
25316 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25317 {
25318         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25319         ndr->depth++;
25320         if (flags & NDR_SET_VALUES) {
25321                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25322         }
25323         if (flags & NDR_IN) {
25324                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25325                 ndr->depth++;
25326                 ndr->depth--;
25327         }
25328         if (flags & NDR_OUT) {
25329                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25330                 ndr->depth++;
25331                 ndr_print_WERROR(ndr, "result", r->out.result);
25332                 ndr->depth--;
25333         }
25334         ndr->depth--;
25335 }
25336
25337 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25338 {
25339         if (flags & NDR_IN) {
25340         }
25341         if (flags & NDR_OUT) {
25342                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25343         }
25344         return NDR_ERR_SUCCESS;
25345 }
25346
25347 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25348 {
25349         if (flags & NDR_IN) {
25350         }
25351         if (flags & NDR_OUT) {
25352                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25353         }
25354         return NDR_ERR_SUCCESS;
25355 }
25356
25357 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25358 {
25359         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25360         ndr->depth++;
25361         if (flags & NDR_SET_VALUES) {
25362                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25363         }
25364         if (flags & NDR_IN) {
25365                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25366                 ndr->depth++;
25367                 ndr->depth--;
25368         }
25369         if (flags & NDR_OUT) {
25370                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25371                 ndr->depth++;
25372                 ndr_print_WERROR(ndr, "result", r->out.result);
25373                 ndr->depth--;
25374         }
25375         ndr->depth--;
25376 }
25377
25378 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25379 {
25380         if (flags & NDR_IN) {
25381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25382                 if (r->in.servername) {
25383                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25384                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25385                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25387                 }
25388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25389                 if (r->in.print_processor_name) {
25390                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25391                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25393                         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));
25394                 }
25395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25397                 if (r->in.buffer) {
25398                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25399                 }
25400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25401         }
25402         if (flags & NDR_OUT) {
25403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25404                 if (r->out.info) {
25405                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25406                 }
25407                 if (r->out.needed == NULL) {
25408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25409                 }
25410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25411                 if (r->out.count == NULL) {
25412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25413                 }
25414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25415                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25416         }
25417         return NDR_ERR_SUCCESS;
25418 }
25419
25420 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25421 {
25422         uint32_t _ptr_servername;
25423         uint32_t _ptr_print_processor_name;
25424         uint32_t _ptr_buffer;
25425         uint32_t _ptr_info;
25426         TALLOC_CTX *_mem_save_servername_0;
25427         TALLOC_CTX *_mem_save_print_processor_name_0;
25428         TALLOC_CTX *_mem_save_buffer_0;
25429         TALLOC_CTX *_mem_save_info_0;
25430         TALLOC_CTX *_mem_save_needed_0;
25431         TALLOC_CTX *_mem_save_count_0;
25432         if (flags & NDR_IN) {
25433                 ZERO_STRUCT(r->out);
25434
25435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25436                 if (_ptr_servername) {
25437                         NDR_PULL_ALLOC(ndr, r->in.servername);
25438                 } else {
25439                         r->in.servername = NULL;
25440                 }
25441                 if (r->in.servername) {
25442                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25443                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25446                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25447                                 return 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));
25448                         }
25449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25452                 }
25453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25454                 if (_ptr_print_processor_name) {
25455                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25456                 } else {
25457                         r->in.print_processor_name = NULL;
25458                 }
25459                 if (r->in.print_processor_name) {
25460                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25461                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25462                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25463                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25464                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25465                                 return 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));
25466                         }
25467                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25468                         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));
25469                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25470                 }
25471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25473                 if (_ptr_buffer) {
25474                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25475                 } else {
25476                         r->in.buffer = NULL;
25477                 }
25478                 if (r->in.buffer) {
25479                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25480                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25481                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25482                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25483                 }
25484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25485                 NDR_PULL_ALLOC(ndr, r->out.needed);
25486                 ZERO_STRUCTP(r->out.needed);
25487                 NDR_PULL_ALLOC(ndr, r->out.count);
25488                 ZERO_STRUCTP(r->out.count);
25489         }
25490         if (flags & NDR_OUT) {
25491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25492                 if (_ptr_info) {
25493                         NDR_PULL_ALLOC(ndr, r->out.info);
25494                 } else {
25495                         r->out.info = NULL;
25496                 }
25497                 if (r->out.info) {
25498                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25499                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25500                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25502                 }
25503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25504                         NDR_PULL_ALLOC(ndr, r->out.needed);
25505                 }
25506                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25507                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25511                         NDR_PULL_ALLOC(ndr, r->out.count);
25512                 }
25513                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25514                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25517                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25518         }
25519         return NDR_ERR_SUCCESS;
25520 }
25521
25522 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25523 {
25524         uint32_t cntr_info_0;
25525         if (flags & NDR_IN) {
25526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25528         }
25529         if (flags & NDR_OUT) {
25530                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25531                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25532                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25533                 }
25534                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25535                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25536                 }
25537         }
25538         return NDR_ERR_SUCCESS;
25539 }
25540
25541 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25542 {
25543         uint32_t cntr_info_0;
25544         TALLOC_CTX *_mem_save_info_0;
25545         if (flags & NDR_IN) {
25546                 ZERO_STRUCT(r->out);
25547
25548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25550         }
25551         if (flags & NDR_OUT) {
25552                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25553                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25554                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25555                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25556                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25557                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25558                 }
25559                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25560                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25561                 }
25562                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25563         }
25564         return NDR_ERR_SUCCESS;
25565 }
25566
25567 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
25568 {
25569         uint32_t cntr_info_2;
25570         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
25571         ndr->depth++;
25572         if (flags & NDR_SET_VALUES) {
25573                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25574         }
25575         if (flags & NDR_IN) {
25576                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
25577                 ndr->depth++;
25578                 ndr_print_ptr(ndr, "servername", r->in.servername);
25579                 ndr->depth++;
25580                 if (r->in.servername) {
25581                         ndr_print_string(ndr, "servername", r->in.servername);
25582                 }
25583                 ndr->depth--;
25584                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25585                 ndr->depth++;
25586                 if (r->in.print_processor_name) {
25587                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25588                 }
25589                 ndr->depth--;
25590                 ndr_print_uint32(ndr, "level", r->in.level);
25591                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25592                 ndr->depth++;
25593                 if (r->in.buffer) {
25594                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25595                 }
25596                 ndr->depth--;
25597                 ndr_print_uint32(ndr, "offered", r->in.offered);
25598                 ndr->depth--;
25599         }
25600         if (flags & NDR_OUT) {
25601                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25602                 ndr->depth++;
25603                 ndr_print_ptr(ndr, "count", r->out.count);
25604                 ndr->depth++;
25605                 ndr_print_uint32(ndr, "count", *r->out.count);
25606                 ndr->depth--;
25607                 ndr_print_ptr(ndr, "info", r->out.info);
25608                 ndr->depth++;
25609                 ndr_print_ptr(ndr, "info", *r->out.info);
25610                 ndr->depth++;
25611                 if (*r->out.info) {
25612                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25613                         ndr->depth++;
25614                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25615                                 char *idx_2=NULL;
25616                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25617                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25618                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25619                                         free(idx_2);
25620                                 }
25621                         }
25622                         ndr->depth--;
25623                 }
25624                 ndr->depth--;
25625                 ndr->depth--;
25626                 ndr_print_ptr(ndr, "needed", r->out.needed);
25627                 ndr->depth++;
25628                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25629                 ndr->depth--;
25630                 ndr_print_WERROR(ndr, "result", r->out.result);
25631                 ndr->depth--;
25632         }
25633         ndr->depth--;
25634 }
25635
25636 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25637 {
25638         if (flags & NDR_IN) {
25639                 if (r->in.handle == NULL) {
25640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25641                 }
25642                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25644                 if (r->in.data_type) {
25645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25648                         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));
25649                 }
25650                 if (r->in.devmode_ctr == NULL) {
25651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25652                 }
25653                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25654         }
25655         if (flags & NDR_OUT) {
25656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25657         }
25658         return NDR_ERR_SUCCESS;
25659 }
25660
25661 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25662 {
25663         uint32_t _ptr_data_type;
25664         TALLOC_CTX *_mem_save_handle_0;
25665         TALLOC_CTX *_mem_save_data_type_0;
25666         TALLOC_CTX *_mem_save_devmode_ctr_0;
25667         if (flags & NDR_IN) {
25668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25669                         NDR_PULL_ALLOC(ndr, r->in.handle);
25670                 }
25671                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25672                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25673                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25675                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25676                 if (_ptr_data_type) {
25677                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25678                 } else {
25679                         r->in.data_type = NULL;
25680                 }
25681                 if (r->in.data_type) {
25682                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25683                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25685                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25686                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25687                                 return 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));
25688                         }
25689                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
25690                         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));
25691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
25692                 }
25693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25694                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25695                 }
25696                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25697                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25698                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25700         }
25701         if (flags & NDR_OUT) {
25702                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25703         }
25704         return NDR_ERR_SUCCESS;
25705 }
25706
25707 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
25708 {
25709         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
25710         ndr->depth++;
25711         if (flags & NDR_SET_VALUES) {
25712                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25713         }
25714         if (flags & NDR_IN) {
25715                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
25716                 ndr->depth++;
25717                 ndr_print_ptr(ndr, "handle", r->in.handle);
25718                 ndr->depth++;
25719                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25720                 ndr->depth--;
25721                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
25722                 ndr->depth++;
25723                 if (r->in.data_type) {
25724                         ndr_print_string(ndr, "data_type", r->in.data_type);
25725                 }
25726                 ndr->depth--;
25727                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25728                 ndr->depth++;
25729                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25730                 ndr->depth--;
25731                 ndr->depth--;
25732         }
25733         if (flags & NDR_OUT) {
25734                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
25735                 ndr->depth++;
25736                 ndr_print_WERROR(ndr, "result", r->out.result);
25737                 ndr->depth--;
25738         }
25739         ndr->depth--;
25740 }
25741
25742 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
25743 {
25744         if (flags & NDR_IN) {
25745                 if (r->in.handle == NULL) {
25746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25747                 }
25748                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
25750                 if (r->in.architecture) {
25751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25755                 }
25756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25758                 if (r->in.buffer) {
25759                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25760                 }
25761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
25763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
25764         }
25765         if (flags & NDR_OUT) {
25766                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25767                 if (r->out.info) {
25768                         {
25769                                 struct ndr_push *_ndr_info;
25770                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25771                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
25772                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25773                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25774                         }
25775                 }
25776                 if (r->out.needed == NULL) {
25777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25778                 }
25779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25780                 if (r->out.server_major_version == NULL) {
25781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25782                 }
25783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
25784                 if (r->out.server_minor_version == NULL) {
25785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25786                 }
25787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
25788                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25789         }
25790         return NDR_ERR_SUCCESS;
25791 }
25792
25793 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
25794 {
25795         uint32_t _ptr_architecture;
25796         uint32_t _ptr_buffer;
25797         uint32_t _ptr_info;
25798         TALLOC_CTX *_mem_save_handle_0;
25799         TALLOC_CTX *_mem_save_architecture_0;
25800         TALLOC_CTX *_mem_save_buffer_0;
25801         TALLOC_CTX *_mem_save_info_0;
25802         TALLOC_CTX *_mem_save_needed_0;
25803         TALLOC_CTX *_mem_save_server_major_version_0;
25804         TALLOC_CTX *_mem_save_server_minor_version_0;
25805         if (flags & NDR_IN) {
25806                 ZERO_STRUCT(r->out);
25807
25808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25809                         NDR_PULL_ALLOC(ndr, r->in.handle);
25810                 }
25811                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25813                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
25816                 if (_ptr_architecture) {
25817                         NDR_PULL_ALLOC(ndr, r->in.architecture);
25818                 } else {
25819                         r->in.architecture = NULL;
25820                 }
25821                 if (r->in.architecture) {
25822                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
25823                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
25824                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
25825                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
25826                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
25827                                 return 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));
25828                         }
25829                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
25830                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
25831                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
25832                 }
25833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25835                 if (_ptr_buffer) {
25836                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25837                 } else {
25838                         r->in.buffer = NULL;
25839                 }
25840                 if (r->in.buffer) {
25841                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25842                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25843                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25845                 }
25846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
25848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
25849                 NDR_PULL_ALLOC(ndr, r->out.needed);
25850                 ZERO_STRUCTP(r->out.needed);
25851                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25852                 ZERO_STRUCTP(r->out.server_major_version);
25853                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25854                 ZERO_STRUCTP(r->out.server_minor_version);
25855         }
25856         if (flags & NDR_OUT) {
25857                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25858                 if (_ptr_info) {
25859                         NDR_PULL_ALLOC(ndr, r->out.info);
25860                 } else {
25861                         r->out.info = NULL;
25862                 }
25863                 if (r->out.info) {
25864                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25865                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25866                         {
25867                                 struct ndr_pull *_ndr_info;
25868                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25869                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
25870                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25871                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25872                         }
25873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25874                 }
25875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25876                         NDR_PULL_ALLOC(ndr, r->out.needed);
25877                 }
25878                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25879                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25883                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25884                 }
25885                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25886                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25889                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25890                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25891                 }
25892                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25893                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
25894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
25895                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
25896                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25897         }
25898         return NDR_ERR_SUCCESS;
25899 }
25900
25901 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
25902 {
25903         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
25904         ndr->depth++;
25905         if (flags & NDR_SET_VALUES) {
25906                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25907         }
25908         if (flags & NDR_IN) {
25909                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
25910                 ndr->depth++;
25911                 ndr_print_ptr(ndr, "handle", r->in.handle);
25912                 ndr->depth++;
25913                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25914                 ndr->depth--;
25915                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
25916                 ndr->depth++;
25917                 if (r->in.architecture) {
25918                         ndr_print_string(ndr, "architecture", r->in.architecture);
25919                 }
25920                 ndr->depth--;
25921                 ndr_print_uint32(ndr, "level", r->in.level);
25922                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25923                 ndr->depth++;
25924                 if (r->in.buffer) {
25925                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25926                 }
25927                 ndr->depth--;
25928                 ndr_print_uint32(ndr, "offered", r->in.offered);
25929                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
25930                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
25931                 ndr->depth--;
25932         }
25933         if (flags & NDR_OUT) {
25934                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
25935                 ndr->depth++;
25936                 ndr_print_ptr(ndr, "info", r->out.info);
25937                 ndr->depth++;
25938                 if (r->out.info) {
25939                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
25940                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
25941                 }
25942                 ndr->depth--;
25943                 ndr_print_ptr(ndr, "needed", r->out.needed);
25944                 ndr->depth++;
25945                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25946                 ndr->depth--;
25947                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
25948                 ndr->depth++;
25949                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
25950                 ndr->depth--;
25951                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
25952                 ndr->depth++;
25953                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
25954                 ndr->depth--;
25955                 ndr_print_WERROR(ndr, "result", r->out.result);
25956                 ndr->depth--;
25957         }
25958         ndr->depth--;
25959 }
25960
25961 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25962 {
25963         if (flags & NDR_IN) {
25964         }
25965         if (flags & NDR_OUT) {
25966                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25967         }
25968         return NDR_ERR_SUCCESS;
25969 }
25970
25971 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
25972 {
25973         if (flags & NDR_IN) {
25974         }
25975         if (flags & NDR_OUT) {
25976                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25977         }
25978         return NDR_ERR_SUCCESS;
25979 }
25980
25981 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25982 {
25983         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
25984         ndr->depth++;
25985         if (flags & NDR_SET_VALUES) {
25986                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25987         }
25988         if (flags & NDR_IN) {
25989                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
25990                 ndr->depth++;
25991                 ndr->depth--;
25992         }
25993         if (flags & NDR_OUT) {
25994                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
25995                 ndr->depth++;
25996                 ndr_print_WERROR(ndr, "result", r->out.result);
25997                 ndr->depth--;
25998         }
25999         ndr->depth--;
26000 }
26001
26002 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26003 {
26004         if (flags & NDR_IN) {
26005         }
26006         if (flags & NDR_OUT) {
26007                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26008         }
26009         return NDR_ERR_SUCCESS;
26010 }
26011
26012 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26013 {
26014         if (flags & NDR_IN) {
26015         }
26016         if (flags & NDR_OUT) {
26017                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26018         }
26019         return NDR_ERR_SUCCESS;
26020 }
26021
26022 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26023 {
26024         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26025         ndr->depth++;
26026         if (flags & NDR_SET_VALUES) {
26027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26028         }
26029         if (flags & NDR_IN) {
26030                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26031                 ndr->depth++;
26032                 ndr->depth--;
26033         }
26034         if (flags & NDR_OUT) {
26035                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26036                 ndr->depth++;
26037                 ndr_print_WERROR(ndr, "result", r->out.result);
26038                 ndr->depth--;
26039         }
26040         ndr->depth--;
26041 }
26042
26043 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26044 {
26045         if (flags & NDR_IN) {
26046                 if (r->in.handle == NULL) {
26047                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26048                 }
26049                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26050         }
26051         if (flags & NDR_OUT) {
26052                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26053         }
26054         return NDR_ERR_SUCCESS;
26055 }
26056
26057 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26058 {
26059         TALLOC_CTX *_mem_save_handle_0;
26060         if (flags & NDR_IN) {
26061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26062                         NDR_PULL_ALLOC(ndr, r->in.handle);
26063                 }
26064                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26065                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26066                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26068         }
26069         if (flags & NDR_OUT) {
26070                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26071         }
26072         return NDR_ERR_SUCCESS;
26073 }
26074
26075 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26076 {
26077         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26078         ndr->depth++;
26079         if (flags & NDR_SET_VALUES) {
26080                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26081         }
26082         if (flags & NDR_IN) {
26083                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26084                 ndr->depth++;
26085                 ndr_print_ptr(ndr, "handle", r->in.handle);
26086                 ndr->depth++;
26087                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26088                 ndr->depth--;
26089                 ndr->depth--;
26090         }
26091         if (flags & NDR_OUT) {
26092                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26093                 ndr->depth++;
26094                 ndr_print_WERROR(ndr, "result", r->out.result);
26095                 ndr->depth--;
26096         }
26097         ndr->depth--;
26098 }
26099
26100 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26101 {
26102         if (flags & NDR_IN) {
26103         }
26104         if (flags & NDR_OUT) {
26105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26106         }
26107         return NDR_ERR_SUCCESS;
26108 }
26109
26110 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26111 {
26112         if (flags & NDR_IN) {
26113         }
26114         if (flags & NDR_OUT) {
26115                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26116         }
26117         return NDR_ERR_SUCCESS;
26118 }
26119
26120 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26121 {
26122         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26123         ndr->depth++;
26124         if (flags & NDR_SET_VALUES) {
26125                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26126         }
26127         if (flags & NDR_IN) {
26128                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26129                 ndr->depth++;
26130                 ndr->depth--;
26131         }
26132         if (flags & NDR_OUT) {
26133                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26134                 ndr->depth++;
26135                 ndr_print_WERROR(ndr, "result", r->out.result);
26136                 ndr->depth--;
26137         }
26138         ndr->depth--;
26139 }
26140
26141 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26142 {
26143         if (flags & NDR_IN) {
26144                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26145                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26146                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26147                 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));
26148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26149                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26152                 if (r->in.buffer) {
26153                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26154                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26155                 }
26156         }
26157         if (flags & NDR_OUT) {
26158                 if (r->out.handle == NULL) {
26159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26160                 }
26161                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26162                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26163         }
26164         return NDR_ERR_SUCCESS;
26165 }
26166
26167 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26168 {
26169         uint32_t _ptr_buffer;
26170         TALLOC_CTX *_mem_save_buffer_0;
26171         TALLOC_CTX *_mem_save_handle_0;
26172         if (flags & NDR_IN) {
26173                 ZERO_STRUCT(r->out);
26174
26175                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26176                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26177                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26178                         return 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));
26179                 }
26180                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26181                 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));
26182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26183                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26185                 if (r->in.bufsize > 512) {
26186                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26187                 }
26188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26189                 if (_ptr_buffer) {
26190                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26191                 } else {
26192                         r->in.buffer = NULL;
26193                 }
26194                 if (r->in.buffer) {
26195                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26196                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26198                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26199                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26201                 }
26202                 NDR_PULL_ALLOC(ndr, r->out.handle);
26203                 ZERO_STRUCTP(r->out.handle);
26204                 if (r->in.buffer) {
26205                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26206                 }
26207         }
26208         if (flags & NDR_OUT) {
26209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26210                         NDR_PULL_ALLOC(ndr, r->out.handle);
26211                 }
26212                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26213                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26214                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26216                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26217         }
26218         return NDR_ERR_SUCCESS;
26219 }
26220
26221 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26222 {
26223         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26224         ndr->depth++;
26225         if (flags & NDR_SET_VALUES) {
26226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26227         }
26228         if (flags & NDR_IN) {
26229                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26230                 ndr->depth++;
26231                 ndr_print_string(ndr, "server_name", r->in.server_name);
26232                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26233                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26234                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26235                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26236                 ndr->depth++;
26237                 if (r->in.buffer) {
26238                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26239                 }
26240                 ndr->depth--;
26241                 ndr->depth--;
26242         }
26243         if (flags & NDR_OUT) {
26244                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26245                 ndr->depth++;
26246                 ndr_print_ptr(ndr, "handle", r->out.handle);
26247                 ndr->depth++;
26248                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26249                 ndr->depth--;
26250                 ndr_print_WERROR(ndr, "result", r->out.result);
26251                 ndr->depth--;
26252         }
26253         ndr->depth--;
26254 }
26255
26256 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26257 {
26258         if (flags & NDR_IN) {
26259                 if (r->in.handle == NULL) {
26260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26261                 }
26262                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26263                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26266                 if (r->in.buffer) {
26267                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26268                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26269                 }
26270         }
26271         if (flags & NDR_OUT) {
26272                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26273         }
26274         return NDR_ERR_SUCCESS;
26275 }
26276
26277 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26278 {
26279         uint32_t _ptr_buffer;
26280         TALLOC_CTX *_mem_save_handle_0;
26281         TALLOC_CTX *_mem_save_buffer_0;
26282         if (flags & NDR_IN) {
26283                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26284                         NDR_PULL_ALLOC(ndr, r->in.handle);
26285                 }
26286                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26287                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26288                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26289                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26290                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26292                 if (r->in.bufsize > 512) {
26293                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26294                 }
26295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26296                 if (_ptr_buffer) {
26297                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26298                 } else {
26299                         r->in.buffer = NULL;
26300                 }
26301                 if (r->in.buffer) {
26302                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26303                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26304                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26305                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26306                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26308                 }
26309                 if (r->in.buffer) {
26310                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26311                 }
26312         }
26313         if (flags & NDR_OUT) {
26314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26315         }
26316         return NDR_ERR_SUCCESS;
26317 }
26318
26319 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26320 {
26321         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26322         ndr->depth++;
26323         if (flags & NDR_SET_VALUES) {
26324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26325         }
26326         if (flags & NDR_IN) {
26327                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26328                 ndr->depth++;
26329                 ndr_print_ptr(ndr, "handle", r->in.handle);
26330                 ndr->depth++;
26331                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26332                 ndr->depth--;
26333                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26334                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26335                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26336                 ndr->depth++;
26337                 if (r->in.buffer) {
26338                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26339                 }
26340                 ndr->depth--;
26341                 ndr->depth--;
26342         }
26343         if (flags & NDR_OUT) {
26344                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26345                 ndr->depth++;
26346                 ndr_print_WERROR(ndr, "result", r->out.result);
26347                 ndr->depth--;
26348         }
26349         ndr->depth--;
26350 }
26351
26352 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26353 {
26354         if (flags & NDR_IN) {
26355                 if (r->in.handle == NULL) {
26356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26357                 }
26358                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26359         }
26360         if (flags & NDR_OUT) {
26361                 if (r->out.handle == NULL) {
26362                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26363                 }
26364                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26366         }
26367         return NDR_ERR_SUCCESS;
26368 }
26369
26370 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26371 {
26372         TALLOC_CTX *_mem_save_handle_0;
26373         if (flags & NDR_IN) {
26374                 ZERO_STRUCT(r->out);
26375
26376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26377                         NDR_PULL_ALLOC(ndr, r->in.handle);
26378                 }
26379                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26380                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26381                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26383                 NDR_PULL_ALLOC(ndr, r->out.handle);
26384                 *r->out.handle = *r->in.handle;
26385         }
26386         if (flags & NDR_OUT) {
26387                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26388                         NDR_PULL_ALLOC(ndr, r->out.handle);
26389                 }
26390                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26391                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26392                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26393                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26394                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26395         }
26396         return NDR_ERR_SUCCESS;
26397 }
26398
26399 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26400 {
26401         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26402         ndr->depth++;
26403         if (flags & NDR_SET_VALUES) {
26404                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26405         }
26406         if (flags & NDR_IN) {
26407                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26408                 ndr->depth++;
26409                 ndr_print_ptr(ndr, "handle", r->in.handle);
26410                 ndr->depth++;
26411                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26412                 ndr->depth--;
26413                 ndr->depth--;
26414         }
26415         if (flags & NDR_OUT) {
26416                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26417                 ndr->depth++;
26418                 ndr_print_ptr(ndr, "handle", r->out.handle);
26419                 ndr->depth++;
26420                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26421                 ndr->depth--;
26422                 ndr_print_WERROR(ndr, "result", r->out.result);
26423                 ndr->depth--;
26424         }
26425         ndr->depth--;
26426 }
26427
26428 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26429 {
26430         if (flags & NDR_IN) {
26431         }
26432         if (flags & NDR_OUT) {
26433                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26434         }
26435         return NDR_ERR_SUCCESS;
26436 }
26437
26438 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26439 {
26440         if (flags & NDR_IN) {
26441         }
26442         if (flags & NDR_OUT) {
26443                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26444         }
26445         return NDR_ERR_SUCCESS;
26446 }
26447
26448 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26449 {
26450         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
26451         ndr->depth++;
26452         if (flags & NDR_SET_VALUES) {
26453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26454         }
26455         if (flags & NDR_IN) {
26456                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
26457                 ndr->depth++;
26458                 ndr->depth--;
26459         }
26460         if (flags & NDR_OUT) {
26461                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26462                 ndr->depth++;
26463                 ndr_print_WERROR(ndr, "result", r->out.result);
26464                 ndr->depth--;
26465         }
26466         ndr->depth--;
26467 }
26468
26469 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26470 {
26471         if (flags & NDR_IN) {
26472         }
26473         if (flags & NDR_OUT) {
26474                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26475         }
26476         return NDR_ERR_SUCCESS;
26477 }
26478
26479 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26480 {
26481         if (flags & NDR_IN) {
26482         }
26483         if (flags & NDR_OUT) {
26484                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26485         }
26486         return NDR_ERR_SUCCESS;
26487 }
26488
26489 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26490 {
26491         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26492         ndr->depth++;
26493         if (flags & NDR_SET_VALUES) {
26494                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26495         }
26496         if (flags & NDR_IN) {
26497                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26498                 ndr->depth++;
26499                 ndr->depth--;
26500         }
26501         if (flags & NDR_OUT) {
26502                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26503                 ndr->depth++;
26504                 ndr_print_WERROR(ndr, "result", r->out.result);
26505                 ndr->depth--;
26506         }
26507         ndr->depth--;
26508 }
26509
26510 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26511 {
26512         if (flags & NDR_IN) {
26513         }
26514         if (flags & NDR_OUT) {
26515                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26516         }
26517         return NDR_ERR_SUCCESS;
26518 }
26519
26520 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26521 {
26522         if (flags & NDR_IN) {
26523         }
26524         if (flags & NDR_OUT) {
26525                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26526         }
26527         return NDR_ERR_SUCCESS;
26528 }
26529
26530 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26531 {
26532         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26533         ndr->depth++;
26534         if (flags & NDR_SET_VALUES) {
26535                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26536         }
26537         if (flags & NDR_IN) {
26538                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26539                 ndr->depth++;
26540                 ndr->depth--;
26541         }
26542         if (flags & NDR_OUT) {
26543                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26544                 ndr->depth++;
26545                 ndr_print_WERROR(ndr, "result", r->out.result);
26546                 ndr->depth--;
26547         }
26548         ndr->depth--;
26549 }
26550
26551 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
26552 {
26553         if (flags & NDR_IN) {
26554         }
26555         if (flags & NDR_OUT) {
26556                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26557         }
26558         return NDR_ERR_SUCCESS;
26559 }
26560
26561 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
26562 {
26563         if (flags & NDR_IN) {
26564         }
26565         if (flags & NDR_OUT) {
26566                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26567         }
26568         return NDR_ERR_SUCCESS;
26569 }
26570
26571 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
26572 {
26573         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
26574         ndr->depth++;
26575         if (flags & NDR_SET_VALUES) {
26576                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26577         }
26578         if (flags & NDR_IN) {
26579                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
26580                 ndr->depth++;
26581                 ndr->depth--;
26582         }
26583         if (flags & NDR_OUT) {
26584                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26585                 ndr->depth++;
26586                 ndr_print_WERROR(ndr, "result", r->out.result);
26587                 ndr->depth--;
26588         }
26589         ndr->depth--;
26590 }
26591
26592 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26593 {
26594         if (flags & NDR_IN) {
26595                 if (r->in.handle == NULL) {
26596                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26597                 }
26598                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26599                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26602                 if (r->in.local_machine) {
26603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26606                         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));
26607                 }
26608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26610                 if (r->in.notify_options) {
26611                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26612                 }
26613         }
26614         if (flags & NDR_OUT) {
26615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26616         }
26617         return NDR_ERR_SUCCESS;
26618 }
26619
26620 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26621 {
26622         uint32_t _ptr_local_machine;
26623         uint32_t _ptr_notify_options;
26624         TALLOC_CTX *_mem_save_handle_0;
26625         TALLOC_CTX *_mem_save_local_machine_0;
26626         TALLOC_CTX *_mem_save_notify_options_0;
26627         if (flags & NDR_IN) {
26628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26629                         NDR_PULL_ALLOC(ndr, r->in.handle);
26630                 }
26631                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26632                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26635                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26638                 if (_ptr_local_machine) {
26639                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
26640                 } else {
26641                         r->in.local_machine = NULL;
26642                 }
26643                 if (r->in.local_machine) {
26644                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26645                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26646                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26647                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26648                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26649                                 return 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));
26650                         }
26651                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26652                         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));
26653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26654                 }
26655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26657                 if (_ptr_notify_options) {
26658                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
26659                 } else {
26660                         r->in.notify_options = NULL;
26661                 }
26662                 if (r->in.notify_options) {
26663                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26664                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26665                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26667                 }
26668         }
26669         if (flags & NDR_OUT) {
26670                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26671         }
26672         return NDR_ERR_SUCCESS;
26673 }
26674
26675 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26676 {
26677         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26678         ndr->depth++;
26679         if (flags & NDR_SET_VALUES) {
26680                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26681         }
26682         if (flags & NDR_IN) {
26683                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26684                 ndr->depth++;
26685                 ndr_print_ptr(ndr, "handle", r->in.handle);
26686                 ndr->depth++;
26687                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26688                 ndr->depth--;
26689                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26690                 ndr_print_uint32(ndr, "options", r->in.options);
26691                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
26692                 ndr->depth++;
26693                 if (r->in.local_machine) {
26694                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
26695                 }
26696                 ndr->depth--;
26697                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26698                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
26699                 ndr->depth++;
26700                 if (r->in.notify_options) {
26701                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
26702                 }
26703                 ndr->depth--;
26704                 ndr->depth--;
26705         }
26706         if (flags & NDR_OUT) {
26707                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26708                 ndr->depth++;
26709                 ndr_print_WERROR(ndr, "result", r->out.result);
26710                 ndr->depth--;
26711         }
26712         ndr->depth--;
26713 }
26714
26715 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26716 {
26717         if (flags & NDR_IN) {
26718                 if (r->in.handle == NULL) {
26719                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26720                 }
26721                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
26723                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
26725                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26726                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26727         }
26728         if (flags & NDR_OUT) {
26729                 if (r->out.reply_result == NULL) {
26730                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26731                 }
26732                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
26733                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26734         }
26735         return NDR_ERR_SUCCESS;
26736 }
26737
26738 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
26739 {
26740         TALLOC_CTX *_mem_save_handle_0;
26741         TALLOC_CTX *_mem_save_reply_result_0;
26742         if (flags & NDR_IN) {
26743                 ZERO_STRUCT(r->out);
26744
26745                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26746                         NDR_PULL_ALLOC(ndr, r->in.handle);
26747                 }
26748                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26749                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26750                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
26753                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
26755                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26756                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26757                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
26758                 ZERO_STRUCTP(r->out.reply_result);
26759         }
26760         if (flags & NDR_OUT) {
26761                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26762                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
26763                 }
26764                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
26765                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
26766                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
26767                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
26768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26769         }
26770         return NDR_ERR_SUCCESS;
26771 }
26772
26773 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26774 {
26775         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
26776         ndr->depth++;
26777         if (flags & NDR_SET_VALUES) {
26778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26779         }
26780         if (flags & NDR_IN) {
26781                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
26782                 ndr->depth++;
26783                 ndr_print_ptr(ndr, "handle", r->in.handle);
26784                 ndr->depth++;
26785                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26786                 ndr->depth--;
26787                 ndr_print_uint32(ndr, "color", r->in.color);
26788                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26789                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
26790                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
26791                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
26792                 ndr->depth--;
26793         }
26794         if (flags & NDR_OUT) {
26795                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
26796                 ndr->depth++;
26797                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
26798                 ndr->depth++;
26799                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
26800                 ndr->depth--;
26801                 ndr_print_WERROR(ndr, "result", r->out.result);
26802                 ndr->depth--;
26803         }
26804         ndr->depth--;
26805 }
26806
26807 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26808 {
26809         if (flags & NDR_IN) {
26810                 if (r->in.handle == NULL) {
26811                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26812                 }
26813                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
26815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
26816                 if (r->in.options) {
26817                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26818                 }
26819         }
26820         if (flags & NDR_OUT) {
26821                 if (r->out.info == NULL) {
26822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26823                 }
26824                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
26825                 if (*r->out.info) {
26826                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26827                 }
26828                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26829         }
26830         return NDR_ERR_SUCCESS;
26831 }
26832
26833 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
26834 {
26835         uint32_t _ptr_options;
26836         uint32_t _ptr_info;
26837         TALLOC_CTX *_mem_save_handle_0;
26838         TALLOC_CTX *_mem_save_options_0;
26839         TALLOC_CTX *_mem_save_info_0;
26840         TALLOC_CTX *_mem_save_info_1;
26841         if (flags & NDR_IN) {
26842                 ZERO_STRUCT(r->out);
26843
26844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26845                         NDR_PULL_ALLOC(ndr, r->in.handle);
26846                 }
26847                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26848                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26849                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
26852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
26853                 if (_ptr_options) {
26854                         NDR_PULL_ALLOC(ndr, r->in.options);
26855                 } else {
26856                         r->in.options = NULL;
26857                 }
26858                 if (r->in.options) {
26859                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26860                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
26861                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
26863                 }
26864                 NDR_PULL_ALLOC(ndr, r->out.info);
26865                 ZERO_STRUCTP(r->out.info);
26866         }
26867         if (flags & NDR_OUT) {
26868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26869                         NDR_PULL_ALLOC(ndr, r->out.info);
26870                 }
26871                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26874                 if (_ptr_info) {
26875                         NDR_PULL_ALLOC(ndr, *r->out.info);
26876                 } else {
26877                         *r->out.info = NULL;
26878                 }
26879                 if (*r->out.info) {
26880                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26881                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26882                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26884                 }
26885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26887         }
26888         return NDR_ERR_SUCCESS;
26889 }
26890
26891 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26892 {
26893         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
26894         ndr->depth++;
26895         if (flags & NDR_SET_VALUES) {
26896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26897         }
26898         if (flags & NDR_IN) {
26899                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
26900                 ndr->depth++;
26901                 ndr_print_ptr(ndr, "handle", r->in.handle);
26902                 ndr->depth++;
26903                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26904                 ndr->depth--;
26905                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
26906                 ndr_print_ptr(ndr, "options", r->in.options);
26907                 ndr->depth++;
26908                 if (r->in.options) {
26909                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
26910                 }
26911                 ndr->depth--;
26912                 ndr->depth--;
26913         }
26914         if (flags & NDR_OUT) {
26915                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
26916                 ndr->depth++;
26917                 ndr_print_ptr(ndr, "info", r->out.info);
26918                 ndr->depth++;
26919                 ndr_print_ptr(ndr, "info", *r->out.info);
26920                 ndr->depth++;
26921                 if (*r->out.info) {
26922                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
26923                 }
26924                 ndr->depth--;
26925                 ndr->depth--;
26926                 ndr_print_WERROR(ndr, "result", r->out.result);
26927                 ndr->depth--;
26928         }
26929         ndr->depth--;
26930 }
26931
26932 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
26933 {
26934         if (flags & NDR_IN) {
26935         }
26936         if (flags & NDR_OUT) {
26937                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26938         }
26939         return NDR_ERR_SUCCESS;
26940 }
26941
26942 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
26943 {
26944         if (flags & NDR_IN) {
26945         }
26946         if (flags & NDR_OUT) {
26947                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26948         }
26949         return NDR_ERR_SUCCESS;
26950 }
26951
26952 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
26953 {
26954         ndr_print_struct(ndr, name, "spoolss_44");
26955         ndr->depth++;
26956         if (flags & NDR_SET_VALUES) {
26957                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26958         }
26959         if (flags & NDR_IN) {
26960                 ndr_print_struct(ndr, "in", "spoolss_44");
26961                 ndr->depth++;
26962                 ndr->depth--;
26963         }
26964         if (flags & NDR_OUT) {
26965                 ndr_print_struct(ndr, "out", "spoolss_44");
26966                 ndr->depth++;
26967                 ndr_print_WERROR(ndr, "result", r->out.result);
26968                 ndr->depth--;
26969         }
26970         ndr->depth--;
26971 }
26972
26973 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
26974 {
26975         if (flags & NDR_IN) {
26976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
26977                 if (r->in.printername) {
26978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26980                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26981                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26982                 }
26983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
26984                 if (r->in.datatype) {
26985                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26986                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26988                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26989                 }
26990                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26991                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
26992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26993                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26994                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26995         }
26996         if (flags & NDR_OUT) {
26997                 if (r->out.handle == NULL) {
26998                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26999                 }
27000                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27001                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27002         }
27003         return NDR_ERR_SUCCESS;
27004 }
27005
27006 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27007 {
27008         uint32_t _ptr_printername;
27009         uint32_t _ptr_datatype;
27010         TALLOC_CTX *_mem_save_printername_0;
27011         TALLOC_CTX *_mem_save_datatype_0;
27012         TALLOC_CTX *_mem_save_handle_0;
27013         if (flags & NDR_IN) {
27014                 ZERO_STRUCT(r->out);
27015
27016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27017                 if (_ptr_printername) {
27018                         NDR_PULL_ALLOC(ndr, r->in.printername);
27019                 } else {
27020                         r->in.printername = NULL;
27021                 }
27022                 if (r->in.printername) {
27023                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27024                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27026                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27027                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27028                                 return 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));
27029                         }
27030                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27031                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27033                 }
27034                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27035                 if (_ptr_datatype) {
27036                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27037                 } else {
27038                         r->in.datatype = NULL;
27039                 }
27040                 if (r->in.datatype) {
27041                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27042                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27045                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27046                                 return 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));
27047                         }
27048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27049                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27051                 }
27052                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27053                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27055                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27056                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27057                 NDR_PULL_ALLOC(ndr, r->out.handle);
27058                 ZERO_STRUCTP(r->out.handle);
27059         }
27060         if (flags & NDR_OUT) {
27061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27062                         NDR_PULL_ALLOC(ndr, r->out.handle);
27063                 }
27064                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27065                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27066                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27068                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27069         }
27070         return NDR_ERR_SUCCESS;
27071 }
27072
27073 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27074 {
27075         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27076         ndr->depth++;
27077         if (flags & NDR_SET_VALUES) {
27078                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27079         }
27080         if (flags & NDR_IN) {
27081                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27082                 ndr->depth++;
27083                 ndr_print_ptr(ndr, "printername", r->in.printername);
27084                 ndr->depth++;
27085                 if (r->in.printername) {
27086                         ndr_print_string(ndr, "printername", r->in.printername);
27087                 }
27088                 ndr->depth--;
27089                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27090                 ndr->depth++;
27091                 if (r->in.datatype) {
27092                         ndr_print_string(ndr, "datatype", r->in.datatype);
27093                 }
27094                 ndr->depth--;
27095                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27096                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27097                 ndr_print_uint32(ndr, "level", r->in.level);
27098                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27099                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27100                 ndr->depth--;
27101         }
27102         if (flags & NDR_OUT) {
27103                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27104                 ndr->depth++;
27105                 ndr_print_ptr(ndr, "handle", r->out.handle);
27106                 ndr->depth++;
27107                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27108                 ndr->depth--;
27109                 ndr_print_WERROR(ndr, "result", r->out.result);
27110                 ndr->depth--;
27111         }
27112         ndr->depth--;
27113 }
27114
27115 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27116 {
27117         if (flags & NDR_IN) {
27118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27119                 if (r->in.server) {
27120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27122                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27123                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27124                 }
27125                 if (r->in.info_ctr == NULL) {
27126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27127                 }
27128                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27129                 if (r->in.devmode_ctr == NULL) {
27130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27131                 }
27132                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27133                 if (r->in.secdesc_ctr == NULL) {
27134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27135                 }
27136                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27137                 if (r->in.userlevel_ctr == NULL) {
27138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27139                 }
27140                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27141         }
27142         if (flags & NDR_OUT) {
27143                 if (r->out.handle == NULL) {
27144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27145                 }
27146                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27147                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27148         }
27149         return NDR_ERR_SUCCESS;
27150 }
27151
27152 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27153 {
27154         uint32_t _ptr_server;
27155         TALLOC_CTX *_mem_save_server_0;
27156         TALLOC_CTX *_mem_save_info_ctr_0;
27157         TALLOC_CTX *_mem_save_devmode_ctr_0;
27158         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27159         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27160         TALLOC_CTX *_mem_save_handle_0;
27161         if (flags & NDR_IN) {
27162                 ZERO_STRUCT(r->out);
27163
27164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27165                 if (_ptr_server) {
27166                         NDR_PULL_ALLOC(ndr, r->in.server);
27167                 } else {
27168                         r->in.server = NULL;
27169                 }
27170                 if (r->in.server) {
27171                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27172                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27175                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27176                                 return 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));
27177                         }
27178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27181                 }
27182                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27183                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27184                 }
27185                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27186                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27187                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27190                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27191                 }
27192                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27193                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27194                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27197                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27198                 }
27199                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27200                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27201                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27202                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27203                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27204                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27205                 }
27206                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27207                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27208                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27210                 NDR_PULL_ALLOC(ndr, r->out.handle);
27211                 ZERO_STRUCTP(r->out.handle);
27212         }
27213         if (flags & NDR_OUT) {
27214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27215                         NDR_PULL_ALLOC(ndr, r->out.handle);
27216                 }
27217                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27222         }
27223         return NDR_ERR_SUCCESS;
27224 }
27225
27226 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27227 {
27228         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27229         ndr->depth++;
27230         if (flags & NDR_SET_VALUES) {
27231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27232         }
27233         if (flags & NDR_IN) {
27234                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27235                 ndr->depth++;
27236                 ndr_print_ptr(ndr, "server", r->in.server);
27237                 ndr->depth++;
27238                 if (r->in.server) {
27239                         ndr_print_string(ndr, "server", r->in.server);
27240                 }
27241                 ndr->depth--;
27242                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27243                 ndr->depth++;
27244                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27245                 ndr->depth--;
27246                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27247                 ndr->depth++;
27248                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27249                 ndr->depth--;
27250                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27251                 ndr->depth++;
27252                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27253                 ndr->depth--;
27254                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27255                 ndr->depth++;
27256                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27257                 ndr->depth--;
27258                 ndr->depth--;
27259         }
27260         if (flags & NDR_OUT) {
27261                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27262                 ndr->depth++;
27263                 ndr_print_ptr(ndr, "handle", r->out.handle);
27264                 ndr->depth++;
27265                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27266                 ndr->depth--;
27267                 ndr_print_WERROR(ndr, "result", r->out.result);
27268                 ndr->depth--;
27269         }
27270         ndr->depth--;
27271 }
27272
27273 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27274 {
27275         if (flags & NDR_IN) {
27276         }
27277         if (flags & NDR_OUT) {
27278                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27279         }
27280         return NDR_ERR_SUCCESS;
27281 }
27282
27283 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27284 {
27285         if (flags & NDR_IN) {
27286         }
27287         if (flags & NDR_OUT) {
27288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27289         }
27290         return NDR_ERR_SUCCESS;
27291 }
27292
27293 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27294 {
27295         ndr_print_struct(ndr, name, "spoolss_47");
27296         ndr->depth++;
27297         if (flags & NDR_SET_VALUES) {
27298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27299         }
27300         if (flags & NDR_IN) {
27301                 ndr_print_struct(ndr, "in", "spoolss_47");
27302                 ndr->depth++;
27303                 ndr->depth--;
27304         }
27305         if (flags & NDR_OUT) {
27306                 ndr_print_struct(ndr, "out", "spoolss_47");
27307                 ndr->depth++;
27308                 ndr_print_WERROR(ndr, "result", r->out.result);
27309                 ndr->depth--;
27310         }
27311         ndr->depth--;
27312 }
27313
27314 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27315 {
27316         if (flags & NDR_IN) {
27317                 if (r->in.handle == NULL) {
27318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27319                 }
27320                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27324         }
27325         if (flags & NDR_OUT) {
27326                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27327                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27328                 if (r->out.value_needed == NULL) {
27329                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27330                 }
27331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27332                 if (r->out.type == NULL) {
27333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27334                 }
27335                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27336                 {
27337                         uint32_t _flags_save_uint8 = ndr->flags;
27338                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27339                         if (r->out.data == NULL) {
27340                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27341                         }
27342                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27343                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27344                         ndr->flags = _flags_save_uint8;
27345                 }
27346                 if (r->out.data_needed == NULL) {
27347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27348                 }
27349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27350                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27351         }
27352         return NDR_ERR_SUCCESS;
27353 }
27354
27355 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27356 {
27357         TALLOC_CTX *_mem_save_handle_0;
27358         TALLOC_CTX *_mem_save_value_needed_0;
27359         TALLOC_CTX *_mem_save_type_0;
27360         TALLOC_CTX *_mem_save_data_needed_0;
27361         if (flags & NDR_IN) {
27362                 ZERO_STRUCT(r->out);
27363
27364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27365                         NDR_PULL_ALLOC(ndr, r->in.handle);
27366                 }
27367                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27368                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27369                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27374                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27375                 ZERO_STRUCTP(r->out.value_needed);
27376                 NDR_PULL_ALLOC(ndr, r->out.type);
27377                 ZERO_STRUCTP(r->out.type);
27378                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27379                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27380                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27381                 ZERO_STRUCTP(r->out.data_needed);
27382         }
27383         if (flags & NDR_OUT) {
27384                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27385                 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));
27386                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27387                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27388                 }
27389                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27390                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27393                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27394                         NDR_PULL_ALLOC(ndr, r->out.type);
27395                 }
27396                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27397                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27398                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27400                 {
27401                         uint32_t _flags_save_uint8 = ndr->flags;
27402                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27403                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27404                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27405                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27406                         }
27407                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27408                         ndr->flags = _flags_save_uint8;
27409                 }
27410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27411                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27412                 }
27413                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27414                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27417                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27418                 if (r->out.value_name) {
27419                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27420                 }
27421                 if (r->out.data) {
27422                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27423                 }
27424         }
27425         return NDR_ERR_SUCCESS;
27426 }
27427
27428 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27429 {
27430         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27431         ndr->depth++;
27432         if (flags & NDR_SET_VALUES) {
27433                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27434         }
27435         if (flags & NDR_IN) {
27436                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27437                 ndr->depth++;
27438                 ndr_print_ptr(ndr, "handle", r->in.handle);
27439                 ndr->depth++;
27440                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27441                 ndr->depth--;
27442                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27443                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27444                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27445                 ndr->depth--;
27446         }
27447         if (flags & NDR_OUT) {
27448                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27449                 ndr->depth++;
27450                 ndr_print_string(ndr, "value_name", r->out.value_name);
27451                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27452                 ndr->depth++;
27453                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27454                 ndr->depth--;
27455                 ndr_print_ptr(ndr, "type", r->out.type);
27456                 ndr->depth++;
27457                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27458                 ndr->depth--;
27459                 ndr_print_ptr(ndr, "data", r->out.data);
27460                 ndr->depth++;
27461                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27462                 ndr->depth--;
27463                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27464                 ndr->depth++;
27465                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27466                 ndr->depth--;
27467                 ndr_print_WERROR(ndr, "result", r->out.result);
27468                 ndr->depth--;
27469         }
27470         ndr->depth--;
27471 }
27472
27473 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27474 {
27475         if (flags & NDR_IN) {
27476                 if (r->in.handle == NULL) {
27477                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27478                 }
27479                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27480                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27481                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27482                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27483                 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));
27484         }
27485         if (flags & NDR_OUT) {
27486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27487         }
27488         return NDR_ERR_SUCCESS;
27489 }
27490
27491 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27492 {
27493         TALLOC_CTX *_mem_save_handle_0;
27494         if (flags & NDR_IN) {
27495                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27496                         NDR_PULL_ALLOC(ndr, r->in.handle);
27497                 }
27498                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27499                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27500                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27501                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27502                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27503                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27504                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27505                         return 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));
27506                 }
27507                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27508                 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));
27509         }
27510         if (flags & NDR_OUT) {
27511                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27512         }
27513         return NDR_ERR_SUCCESS;
27514 }
27515
27516 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27517 {
27518         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27519         ndr->depth++;
27520         if (flags & NDR_SET_VALUES) {
27521                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27522         }
27523         if (flags & NDR_IN) {
27524                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27525                 ndr->depth++;
27526                 ndr_print_ptr(ndr, "handle", r->in.handle);
27527                 ndr->depth++;
27528                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27529                 ndr->depth--;
27530                 ndr_print_string(ndr, "value_name", r->in.value_name);
27531                 ndr->depth--;
27532         }
27533         if (flags & NDR_OUT) {
27534                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27535                 ndr->depth++;
27536                 ndr_print_WERROR(ndr, "result", r->out.result);
27537                 ndr->depth--;
27538         }
27539         ndr->depth--;
27540 }
27541
27542 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27543 {
27544         if (flags & NDR_IN) {
27545         }
27546         if (flags & NDR_OUT) {
27547                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27548         }
27549         return NDR_ERR_SUCCESS;
27550 }
27551
27552 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
27553 {
27554         if (flags & NDR_IN) {
27555         }
27556         if (flags & NDR_OUT) {
27557                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27558         }
27559         return NDR_ERR_SUCCESS;
27560 }
27561
27562 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
27563 {
27564         ndr_print_struct(ndr, name, "spoolss_4a");
27565         ndr->depth++;
27566         if (flags & NDR_SET_VALUES) {
27567                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27568         }
27569         if (flags & NDR_IN) {
27570                 ndr_print_struct(ndr, "in", "spoolss_4a");
27571                 ndr->depth++;
27572                 ndr->depth--;
27573         }
27574         if (flags & NDR_OUT) {
27575                 ndr_print_struct(ndr, "out", "spoolss_4a");
27576                 ndr->depth++;
27577                 ndr_print_WERROR(ndr, "result", r->out.result);
27578                 ndr->depth--;
27579         }
27580         ndr->depth--;
27581 }
27582
27583 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27584 {
27585         if (flags & NDR_IN) {
27586         }
27587         if (flags & NDR_OUT) {
27588                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27589         }
27590         return NDR_ERR_SUCCESS;
27591 }
27592
27593 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27594 {
27595         if (flags & NDR_IN) {
27596         }
27597         if (flags & NDR_OUT) {
27598                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27599         }
27600         return NDR_ERR_SUCCESS;
27601 }
27602
27603 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27604 {
27605         ndr_print_struct(ndr, name, "spoolss_4b");
27606         ndr->depth++;
27607         if (flags & NDR_SET_VALUES) {
27608                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27609         }
27610         if (flags & NDR_IN) {
27611                 ndr_print_struct(ndr, "in", "spoolss_4b");
27612                 ndr->depth++;
27613                 ndr->depth--;
27614         }
27615         if (flags & NDR_OUT) {
27616                 ndr_print_struct(ndr, "out", "spoolss_4b");
27617                 ndr->depth++;
27618                 ndr_print_WERROR(ndr, "result", r->out.result);
27619                 ndr->depth--;
27620         }
27621         ndr->depth--;
27622 }
27623
27624 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27625 {
27626         if (flags & NDR_IN) {
27627         }
27628         if (flags & NDR_OUT) {
27629                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27630         }
27631         return NDR_ERR_SUCCESS;
27632 }
27633
27634 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27635 {
27636         if (flags & NDR_IN) {
27637         }
27638         if (flags & NDR_OUT) {
27639                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27640         }
27641         return NDR_ERR_SUCCESS;
27642 }
27643
27644 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27645 {
27646         ndr_print_struct(ndr, name, "spoolss_4c");
27647         ndr->depth++;
27648         if (flags & NDR_SET_VALUES) {
27649                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27650         }
27651         if (flags & NDR_IN) {
27652                 ndr_print_struct(ndr, "in", "spoolss_4c");
27653                 ndr->depth++;
27654                 ndr->depth--;
27655         }
27656         if (flags & NDR_OUT) {
27657                 ndr_print_struct(ndr, "out", "spoolss_4c");
27658                 ndr->depth++;
27659                 ndr_print_WERROR(ndr, "result", r->out.result);
27660                 ndr->depth--;
27661         }
27662         ndr->depth--;
27663 }
27664
27665 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
27666 {
27667         if (flags & NDR_IN) {
27668                 if (r->in.handle == NULL) {
27669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27670                 }
27671                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27672                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27673                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27674                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27675                 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));
27676                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27677                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27678                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27679                 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));
27680                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27681                 if (r->in.buffer == NULL) {
27682                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27683                 }
27684                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27685                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
27686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27687         }
27688         if (flags & NDR_OUT) {
27689                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27690         }
27691         return NDR_ERR_SUCCESS;
27692 }
27693
27694 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
27695 {
27696         TALLOC_CTX *_mem_save_handle_0;
27697         if (flags & NDR_IN) {
27698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27699                         NDR_PULL_ALLOC(ndr, r->in.handle);
27700                 }
27701                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27702                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27703                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27704                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27705                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27706                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27707                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27708                         return 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));
27709                 }
27710                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27711                 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));
27712                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27713                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27714                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27715                         return 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));
27716                 }
27717                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27718                 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));
27719                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27720                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27722                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27723                 }
27724                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27726                 if (r->in.buffer) {
27727                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
27728                 }
27729         }
27730         if (flags & NDR_OUT) {
27731                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27732         }
27733         return NDR_ERR_SUCCESS;
27734 }
27735
27736 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
27737 {
27738         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
27739         ndr->depth++;
27740         if (flags & NDR_SET_VALUES) {
27741                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27742         }
27743         if (flags & NDR_IN) {
27744                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
27745                 ndr->depth++;
27746                 ndr_print_ptr(ndr, "handle", r->in.handle);
27747                 ndr->depth++;
27748                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27749                 ndr->depth--;
27750                 ndr_print_string(ndr, "key_name", r->in.key_name);
27751                 ndr_print_string(ndr, "value_name", r->in.value_name);
27752                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27753                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27754                 ndr->depth++;
27755                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
27756                 ndr->depth--;
27757                 ndr_print_uint32(ndr, "offered", r->in.offered);
27758                 ndr->depth--;
27759         }
27760         if (flags & NDR_OUT) {
27761                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
27762                 ndr->depth++;
27763                 ndr_print_WERROR(ndr, "result", r->out.result);
27764                 ndr->depth--;
27765         }
27766         ndr->depth--;
27767 }
27768
27769 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
27770 {
27771         if (flags & NDR_IN) {
27772                 if (r->in.handle == NULL) {
27773                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27774                 }
27775                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27776                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27777                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27778                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27779                 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));
27780                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27781                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27782                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27783                 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));
27784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27785         }
27786         if (flags & NDR_OUT) {
27787                 if (r->out.type == NULL) {
27788                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27789                 }
27790                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27791                 if (r->out.buffer == NULL) {
27792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27793                 }
27794                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27795                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
27796                 if (r->out.needed == NULL) {
27797                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27798                 }
27799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27800                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27801         }
27802         return NDR_ERR_SUCCESS;
27803 }
27804
27805 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
27806 {
27807         TALLOC_CTX *_mem_save_handle_0;
27808         TALLOC_CTX *_mem_save_type_0;
27809         TALLOC_CTX *_mem_save_needed_0;
27810         if (flags & NDR_IN) {
27811                 ZERO_STRUCT(r->out);
27812
27813                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27814                         NDR_PULL_ALLOC(ndr, r->in.handle);
27815                 }
27816                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27817                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27818                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27820                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27821                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27822                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27823                         return 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));
27824                 }
27825                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27826                 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));
27827                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27828                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27829                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27830                         return 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));
27831                 }
27832                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27833                 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));
27834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27835                 NDR_PULL_ALLOC(ndr, r->out.type);
27836                 ZERO_STRUCTP(r->out.type);
27837                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
27838                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
27839                 NDR_PULL_ALLOC(ndr, r->out.needed);
27840                 ZERO_STRUCTP(r->out.needed);
27841         }
27842         if (flags & NDR_OUT) {
27843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27844                         NDR_PULL_ALLOC(ndr, r->out.type);
27845                 }
27846                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27848                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27850                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
27851                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27852                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
27853                 }
27854                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
27855                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27856                         NDR_PULL_ALLOC(ndr, r->out.needed);
27857                 }
27858                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27859                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27861                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27863                 if (r->out.buffer) {
27864                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
27865                 }
27866         }
27867         return NDR_ERR_SUCCESS;
27868 }
27869
27870 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
27871 {
27872         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
27873         ndr->depth++;
27874         if (flags & NDR_SET_VALUES) {
27875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27876         }
27877         if (flags & NDR_IN) {
27878                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
27879                 ndr->depth++;
27880                 ndr_print_ptr(ndr, "handle", r->in.handle);
27881                 ndr->depth++;
27882                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27883                 ndr->depth--;
27884                 ndr_print_string(ndr, "key_name", r->in.key_name);
27885                 ndr_print_string(ndr, "value_name", r->in.value_name);
27886                 ndr_print_uint32(ndr, "offered", r->in.offered);
27887                 ndr->depth--;
27888         }
27889         if (flags & NDR_OUT) {
27890                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
27891                 ndr->depth++;
27892                 ndr_print_ptr(ndr, "type", r->out.type);
27893                 ndr->depth++;
27894                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27895                 ndr->depth--;
27896                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
27897                 ndr->depth++;
27898                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
27899                 ndr->depth--;
27900                 ndr_print_ptr(ndr, "needed", r->out.needed);
27901                 ndr->depth++;
27902                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27903                 ndr->depth--;
27904                 ndr_print_WERROR(ndr, "result", r->out.result);
27905                 ndr->depth--;
27906         }
27907         ndr->depth--;
27908 }
27909
27910 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
27911 {
27912         if (flags & NDR_IN) {
27913                 if (r->in.handle == NULL) {
27914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27915                 }
27916                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27917                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27918                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27919                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27920                 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));
27921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27922         }
27923         if (flags & NDR_OUT) {
27924                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
27925                 if (r->out.needed == NULL) {
27926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27927                 }
27928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27929                 if (r->out.count == NULL) {
27930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27931                 }
27932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
27933                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27934         }
27935         return NDR_ERR_SUCCESS;
27936 }
27937
27938 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
27939 {
27940         TALLOC_CTX *_mem_save_handle_0;
27941         TALLOC_CTX *_mem_save_needed_0;
27942         TALLOC_CTX *_mem_save_count_0;
27943         if (flags & NDR_IN) {
27944                 ZERO_STRUCT(r->out);
27945
27946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27947                         NDR_PULL_ALLOC(ndr, r->in.handle);
27948                 }
27949                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27950                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27951                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27953                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27954                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27955                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27956                         return 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));
27957                 }
27958                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27959                 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));
27960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27961                 NDR_PULL_ALLOC(ndr, r->out.needed);
27962                 ZERO_STRUCTP(r->out.needed);
27963                 NDR_PULL_ALLOC(ndr, r->out.count);
27964                 ZERO_STRUCTP(r->out.count);
27965         }
27966         if (flags & NDR_OUT) {
27967                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
27968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27969                         NDR_PULL_ALLOC(ndr, r->out.needed);
27970                 }
27971                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27972                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27975                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27976                         NDR_PULL_ALLOC(ndr, r->out.count);
27977                 }
27978                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
27979                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
27980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
27981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
27982                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27983         }
27984         return NDR_ERR_SUCCESS;
27985 }
27986
27987 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
27988 {
27989         uint32_t cntr_info_0;
27990         if (flags & NDR_IN) {
27991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
27992         }
27993         if (flags & NDR_OUT) {
27994                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27995                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27996                 }
27997                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27998                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27999                 }
28000         }
28001         return NDR_ERR_SUCCESS;
28002 }
28003
28004 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28005 {
28006         uint32_t cntr_info_0;
28007         TALLOC_CTX *_mem_save_info_0;
28008         if (flags & NDR_IN) {
28009                 ZERO_STRUCT(r->out);
28010
28011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28012         }
28013         if (flags & NDR_OUT) {
28014                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28015                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28016                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28017                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28018                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28019                 }
28020                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28021                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28022                 }
28023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28024         }
28025         return NDR_ERR_SUCCESS;
28026 }
28027
28028 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28029 {
28030         uint32_t cntr_info_2;
28031         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28032         ndr->depth++;
28033         if (flags & NDR_SET_VALUES) {
28034                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28035         }
28036         if (flags & NDR_IN) {
28037                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28038                 ndr->depth++;
28039                 ndr_print_ptr(ndr, "handle", r->in.handle);
28040                 ndr->depth++;
28041                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28042                 ndr->depth--;
28043                 ndr_print_string(ndr, "key_name", r->in.key_name);
28044                 ndr_print_uint32(ndr, "offered", r->in.offered);
28045                 ndr->depth--;
28046         }
28047         if (flags & NDR_OUT) {
28048                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28049                 ndr->depth++;
28050                 ndr_print_ptr(ndr, "count", r->out.count);
28051                 ndr->depth++;
28052                 ndr_print_uint32(ndr, "count", *r->out.count);
28053                 ndr->depth--;
28054                 ndr_print_ptr(ndr, "info", r->out.info);
28055                 ndr->depth++;
28056                 ndr_print_ptr(ndr, "info", *r->out.info);
28057                 ndr->depth++;
28058                 if (*r->out.info) {
28059                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28060                         ndr->depth++;
28061                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28062                                 char *idx_2=NULL;
28063                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28064                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28065                                         free(idx_2);
28066                                 }
28067                         }
28068                         ndr->depth--;
28069                 }
28070                 ndr->depth--;
28071                 ndr->depth--;
28072                 ndr_print_ptr(ndr, "needed", r->out.needed);
28073                 ndr->depth++;
28074                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28075                 ndr->depth--;
28076                 ndr_print_WERROR(ndr, "result", r->out.result);
28077                 ndr->depth--;
28078         }
28079         ndr->depth--;
28080 }
28081
28082 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28083 {
28084         if (flags & NDR_IN) {
28085                 if (r->in.handle == NULL) {
28086                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28087                 }
28088                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28089                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28090                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28091                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28092                 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));
28093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28094         }
28095         if (flags & NDR_OUT) {
28096                 if (r->out.key_buffer == NULL) {
28097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28098                 }
28099                 NDR_CHECK(ndr_push_spoolss_StringArray2(ndr, NDR_SCALARS, r->out.key_buffer));
28100                 if (r->out.needed == NULL) {
28101                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28102                 }
28103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28104                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28105         }
28106         return NDR_ERR_SUCCESS;
28107 }
28108
28109 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28110 {
28111         TALLOC_CTX *_mem_save_handle_0;
28112         TALLOC_CTX *_mem_save_key_buffer_0;
28113         TALLOC_CTX *_mem_save_needed_0;
28114         if (flags & NDR_IN) {
28115                 ZERO_STRUCT(r->out);
28116
28117                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28118                         NDR_PULL_ALLOC(ndr, r->in.handle);
28119                 }
28120                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28121                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28122                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28124                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28125                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28126                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28127                         return 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));
28128                 }
28129                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28130                 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));
28131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28132                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28133                 ZERO_STRUCTP(r->out.key_buffer);
28134                 NDR_PULL_ALLOC(ndr, r->out.needed);
28135                 ZERO_STRUCTP(r->out.needed);
28136         }
28137         if (flags & NDR_OUT) {
28138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28139                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28140                 }
28141                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28142                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28143                 NDR_CHECK(ndr_pull_spoolss_StringArray2(ndr, NDR_SCALARS, r->out.key_buffer));
28144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28146                         NDR_PULL_ALLOC(ndr, r->out.needed);
28147                 }
28148                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28149                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28153         }
28154         return NDR_ERR_SUCCESS;
28155 }
28156
28157 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28158 {
28159         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28160         ndr->depth++;
28161         if (flags & NDR_SET_VALUES) {
28162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28163         }
28164         if (flags & NDR_IN) {
28165                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28166                 ndr->depth++;
28167                 ndr_print_ptr(ndr, "handle", r->in.handle);
28168                 ndr->depth++;
28169                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28170                 ndr->depth--;
28171                 ndr_print_string(ndr, "key_name", r->in.key_name);
28172                 ndr_print_uint32(ndr, "offered", r->in.offered);
28173                 ndr->depth--;
28174         }
28175         if (flags & NDR_OUT) {
28176                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28177                 ndr->depth++;
28178                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28179                 ndr->depth++;
28180                 ndr_print_spoolss_StringArray2(ndr, "key_buffer", r->out.key_buffer);
28181                 ndr->depth--;
28182                 ndr_print_ptr(ndr, "needed", r->out.needed);
28183                 ndr->depth++;
28184                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28185                 ndr->depth--;
28186                 ndr_print_WERROR(ndr, "result", r->out.result);
28187                 ndr->depth--;
28188         }
28189         ndr->depth--;
28190 }
28191
28192 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28193 {
28194         if (flags & NDR_IN) {
28195                 if (r->in.handle == NULL) {
28196                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28197                 }
28198                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28199                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28200                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28201                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28202                 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));
28203                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28204                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28205                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28206                 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));
28207         }
28208         if (flags & NDR_OUT) {
28209                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28210         }
28211         return NDR_ERR_SUCCESS;
28212 }
28213
28214 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28215 {
28216         TALLOC_CTX *_mem_save_handle_0;
28217         if (flags & NDR_IN) {
28218                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28219                         NDR_PULL_ALLOC(ndr, r->in.handle);
28220                 }
28221                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28222                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28223                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28224                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28225                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28226                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28227                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28228                         return 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));
28229                 }
28230                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28231                 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));
28232                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28233                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28234                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28235                         return 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));
28236                 }
28237                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28238                 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));
28239         }
28240         if (flags & NDR_OUT) {
28241                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28242         }
28243         return NDR_ERR_SUCCESS;
28244 }
28245
28246 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28247 {
28248         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28249         ndr->depth++;
28250         if (flags & NDR_SET_VALUES) {
28251                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28252         }
28253         if (flags & NDR_IN) {
28254                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28255                 ndr->depth++;
28256                 ndr_print_ptr(ndr, "handle", r->in.handle);
28257                 ndr->depth++;
28258                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28259                 ndr->depth--;
28260                 ndr_print_string(ndr, "key_name", r->in.key_name);
28261                 ndr_print_string(ndr, "value_name", r->in.value_name);
28262                 ndr->depth--;
28263         }
28264         if (flags & NDR_OUT) {
28265                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28266                 ndr->depth++;
28267                 ndr_print_WERROR(ndr, "result", r->out.result);
28268                 ndr->depth--;
28269         }
28270         ndr->depth--;
28271 }
28272
28273 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28274 {
28275         if (flags & NDR_IN) {
28276                 if (r->in.handle == NULL) {
28277                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28278                 }
28279                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28280                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28281                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28282                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28283                 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));
28284         }
28285         if (flags & NDR_OUT) {
28286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28287         }
28288         return NDR_ERR_SUCCESS;
28289 }
28290
28291 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28292 {
28293         TALLOC_CTX *_mem_save_handle_0;
28294         if (flags & NDR_IN) {
28295                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28296                         NDR_PULL_ALLOC(ndr, r->in.handle);
28297                 }
28298                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28299                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28300                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28301                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28302                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28303                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28304                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28305                         return 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));
28306                 }
28307                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28308                 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));
28309         }
28310         if (flags & NDR_OUT) {
28311                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28312         }
28313         return NDR_ERR_SUCCESS;
28314 }
28315
28316 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28317 {
28318         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28319         ndr->depth++;
28320         if (flags & NDR_SET_VALUES) {
28321                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28322         }
28323         if (flags & NDR_IN) {
28324                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28325                 ndr->depth++;
28326                 ndr_print_ptr(ndr, "handle", r->in.handle);
28327                 ndr->depth++;
28328                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28329                 ndr->depth--;
28330                 ndr_print_string(ndr, "key_name", r->in.key_name);
28331                 ndr->depth--;
28332         }
28333         if (flags & NDR_OUT) {
28334                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28335                 ndr->depth++;
28336                 ndr_print_WERROR(ndr, "result", r->out.result);
28337                 ndr->depth--;
28338         }
28339         ndr->depth--;
28340 }
28341
28342 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28343 {
28344         if (flags & NDR_IN) {
28345         }
28346         if (flags & NDR_OUT) {
28347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28348         }
28349         return NDR_ERR_SUCCESS;
28350 }
28351
28352 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28353 {
28354         if (flags & NDR_IN) {
28355         }
28356         if (flags & NDR_OUT) {
28357                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28358         }
28359         return NDR_ERR_SUCCESS;
28360 }
28361
28362 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28363 {
28364         ndr_print_struct(ndr, name, "spoolss_53");
28365         ndr->depth++;
28366         if (flags & NDR_SET_VALUES) {
28367                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28368         }
28369         if (flags & NDR_IN) {
28370                 ndr_print_struct(ndr, "in", "spoolss_53");
28371                 ndr->depth++;
28372                 ndr->depth--;
28373         }
28374         if (flags & NDR_OUT) {
28375                 ndr_print_struct(ndr, "out", "spoolss_53");
28376                 ndr->depth++;
28377                 ndr_print_WERROR(ndr, "result", r->out.result);
28378                 ndr->depth--;
28379         }
28380         ndr->depth--;
28381 }
28382
28383 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28384 {
28385         if (flags & NDR_IN) {
28386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28387                 if (r->in.server) {
28388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28389                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28390                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28391                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28392                 }
28393                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28394                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28395                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28396                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28397                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28398                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28399                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28400                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28401                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28403         }
28404         if (flags & NDR_OUT) {
28405                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28406         }
28407         return NDR_ERR_SUCCESS;
28408 }
28409
28410 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28411 {
28412         uint32_t _ptr_server;
28413         TALLOC_CTX *_mem_save_server_0;
28414         if (flags & NDR_IN) {
28415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28416                 if (_ptr_server) {
28417                         NDR_PULL_ALLOC(ndr, r->in.server);
28418                 } else {
28419                         r->in.server = NULL;
28420                 }
28421                 if (r->in.server) {
28422                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28423                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28425                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28426                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28427                                 return 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));
28428                         }
28429                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28430                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28432                 }
28433                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28434                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28435                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28436                         return 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));
28437                 }
28438                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28439                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28440                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28441                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28442                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28443                         return 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));
28444                 }
28445                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28446                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28447                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28449         }
28450         if (flags & NDR_OUT) {
28451                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28452         }
28453         return NDR_ERR_SUCCESS;
28454 }
28455
28456 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28457 {
28458         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28459         ndr->depth++;
28460         if (flags & NDR_SET_VALUES) {
28461                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28462         }
28463         if (flags & NDR_IN) {
28464                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28465                 ndr->depth++;
28466                 ndr_print_ptr(ndr, "server", r->in.server);
28467                 ndr->depth++;
28468                 if (r->in.server) {
28469                         ndr_print_string(ndr, "server", r->in.server);
28470                 }
28471                 ndr->depth--;
28472                 ndr_print_string(ndr, "architecture", r->in.architecture);
28473                 ndr_print_string(ndr, "driver", r->in.driver);
28474                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
28475                 ndr_print_uint32(ndr, "version", r->in.version);
28476                 ndr->depth--;
28477         }
28478         if (flags & NDR_OUT) {
28479                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
28480                 ndr->depth++;
28481                 ndr_print_WERROR(ndr, "result", r->out.result);
28482                 ndr->depth--;
28483         }
28484         ndr->depth--;
28485 }
28486
28487 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
28488 {
28489         if (flags & NDR_IN) {
28490         }
28491         if (flags & NDR_OUT) {
28492                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28493         }
28494         return NDR_ERR_SUCCESS;
28495 }
28496
28497 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
28498 {
28499         if (flags & NDR_IN) {
28500         }
28501         if (flags & NDR_OUT) {
28502                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28503         }
28504         return NDR_ERR_SUCCESS;
28505 }
28506
28507 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
28508 {
28509         ndr_print_struct(ndr, name, "spoolss_55");
28510         ndr->depth++;
28511         if (flags & NDR_SET_VALUES) {
28512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28513         }
28514         if (flags & NDR_IN) {
28515                 ndr_print_struct(ndr, "in", "spoolss_55");
28516                 ndr->depth++;
28517                 ndr->depth--;
28518         }
28519         if (flags & NDR_OUT) {
28520                 ndr_print_struct(ndr, "out", "spoolss_55");
28521                 ndr->depth++;
28522                 ndr_print_WERROR(ndr, "result", r->out.result);
28523                 ndr->depth--;
28524         }
28525         ndr->depth--;
28526 }
28527
28528 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
28529 {
28530         if (flags & NDR_IN) {
28531         }
28532         if (flags & NDR_OUT) {
28533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28534         }
28535         return NDR_ERR_SUCCESS;
28536 }
28537
28538 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
28539 {
28540         if (flags & NDR_IN) {
28541         }
28542         if (flags & NDR_OUT) {
28543                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28544         }
28545         return NDR_ERR_SUCCESS;
28546 }
28547
28548 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28549 {
28550         ndr_print_struct(ndr, name, "spoolss_56");
28551         ndr->depth++;
28552         if (flags & NDR_SET_VALUES) {
28553                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28554         }
28555         if (flags & NDR_IN) {
28556                 ndr_print_struct(ndr, "in", "spoolss_56");
28557                 ndr->depth++;
28558                 ndr->depth--;
28559         }
28560         if (flags & NDR_OUT) {
28561                 ndr_print_struct(ndr, "out", "spoolss_56");
28562                 ndr->depth++;
28563                 ndr_print_WERROR(ndr, "result", r->out.result);
28564                 ndr->depth--;
28565         }
28566         ndr->depth--;
28567 }
28568
28569 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28570 {
28571         if (flags & NDR_IN) {
28572         }
28573         if (flags & NDR_OUT) {
28574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28575         }
28576         return NDR_ERR_SUCCESS;
28577 }
28578
28579 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28580 {
28581         if (flags & NDR_IN) {
28582         }
28583         if (flags & NDR_OUT) {
28584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28585         }
28586         return NDR_ERR_SUCCESS;
28587 }
28588
28589 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28590 {
28591         ndr_print_struct(ndr, name, "spoolss_57");
28592         ndr->depth++;
28593         if (flags & NDR_SET_VALUES) {
28594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28595         }
28596         if (flags & NDR_IN) {
28597                 ndr_print_struct(ndr, "in", "spoolss_57");
28598                 ndr->depth++;
28599                 ndr->depth--;
28600         }
28601         if (flags & NDR_OUT) {
28602                 ndr_print_struct(ndr, "out", "spoolss_57");
28603                 ndr->depth++;
28604                 ndr_print_WERROR(ndr, "result", r->out.result);
28605                 ndr->depth--;
28606         }
28607         ndr->depth--;
28608 }
28609
28610 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
28611 {
28612         if (flags & NDR_IN) {
28613                 if (r->in.handle == NULL) {
28614                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28615                 }
28616                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28617                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28618                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28619                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28620                 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));
28621                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
28622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
28623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28624                 if (r->in.status_code == NULL) {
28625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28626                 }
28627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
28628         }
28629         if (flags & NDR_OUT) {
28630                 if (r->out.out_data == NULL) {
28631                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28632                 }
28633                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
28634                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
28635                 if (r->out.needed == NULL) {
28636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28637                 }
28638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28639                 if (r->out.status_code == NULL) {
28640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28641                 }
28642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
28643                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28644         }
28645         return NDR_ERR_SUCCESS;
28646 }
28647
28648 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
28649 {
28650         TALLOC_CTX *_mem_save_handle_0;
28651         TALLOC_CTX *_mem_save_needed_0;
28652         TALLOC_CTX *_mem_save_status_code_0;
28653         if (flags & NDR_IN) {
28654                 ZERO_STRUCT(r->out);
28655
28656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28657                         NDR_PULL_ALLOC(ndr, r->in.handle);
28658                 }
28659                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28661                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28663                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
28664                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
28665                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
28666                         return 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));
28667                 }
28668                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
28669                 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));
28670                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
28671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
28672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
28673                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28674                         NDR_PULL_ALLOC(ndr, r->in.status_code);
28675                 }
28676                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28677                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
28678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
28679                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28680                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
28681                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
28682                 NDR_PULL_ALLOC(ndr, r->out.needed);
28683                 ZERO_STRUCTP(r->out.needed);
28684                 NDR_PULL_ALLOC(ndr, r->out.status_code);
28685                 *r->out.status_code = *r->in.status_code;
28686         }
28687         if (flags & NDR_OUT) {
28688                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
28689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28690                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
28691                 }
28692                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
28693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28694                         NDR_PULL_ALLOC(ndr, r->out.needed);
28695                 }
28696                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28697                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28700                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28701                         NDR_PULL_ALLOC(ndr, r->out.status_code);
28702                 }
28703                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28704                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
28705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
28706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28708                 if (r->out.out_data) {
28709                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
28710                 }
28711         }
28712         return NDR_ERR_SUCCESS;
28713 }
28714
28715 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
28716 {
28717         ndr_print_struct(ndr, name, "spoolss_XcvData");
28718         ndr->depth++;
28719         if (flags & NDR_SET_VALUES) {
28720                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28721         }
28722         if (flags & NDR_IN) {
28723                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
28724                 ndr->depth++;
28725                 ndr_print_ptr(ndr, "handle", r->in.handle);
28726                 ndr->depth++;
28727                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28728                 ndr->depth--;
28729                 ndr_print_string(ndr, "function_name", r->in.function_name);
28730                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
28731                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
28732                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
28733                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
28734                 ndr->depth++;
28735                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
28736                 ndr->depth--;
28737                 ndr->depth--;
28738         }
28739         if (flags & NDR_OUT) {
28740                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
28741                 ndr->depth++;
28742                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
28743                 ndr->depth++;
28744                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
28745                 ndr->depth--;
28746                 ndr_print_ptr(ndr, "needed", r->out.needed);
28747                 ndr->depth++;
28748                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28749                 ndr->depth--;
28750                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
28751                 ndr->depth++;
28752                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
28753                 ndr->depth--;
28754                 ndr_print_WERROR(ndr, "result", r->out.result);
28755                 ndr->depth--;
28756         }
28757         ndr->depth--;
28758 }
28759
28760 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
28761 {
28762         if (flags & NDR_IN) {
28763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28764                 if (r->in.servername) {
28765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28767                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28768                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28769                 }
28770                 if (r->in.info_ctr == NULL) {
28771                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28772                 }
28773                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28774                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
28775         }
28776         if (flags & NDR_OUT) {
28777                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28778         }
28779         return NDR_ERR_SUCCESS;
28780 }
28781
28782 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
28783 {
28784         uint32_t _ptr_servername;
28785         TALLOC_CTX *_mem_save_servername_0;
28786         TALLOC_CTX *_mem_save_info_ctr_0;
28787         if (flags & NDR_IN) {
28788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28789                 if (_ptr_servername) {
28790                         NDR_PULL_ALLOC(ndr, r->in.servername);
28791                 } else {
28792                         r->in.servername = NULL;
28793                 }
28794                 if (r->in.servername) {
28795                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28796                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28797                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28798                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28799                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28800                                 return 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));
28801                         }
28802                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28803                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28804                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28805                 }
28806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28807                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28808                 }
28809                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28810                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28811                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28813                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
28814         }
28815         if (flags & NDR_OUT) {
28816                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28817         }
28818         return NDR_ERR_SUCCESS;
28819 }
28820
28821 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
28822 {
28823         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
28824         ndr->depth++;
28825         if (flags & NDR_SET_VALUES) {
28826                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28827         }
28828         if (flags & NDR_IN) {
28829                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
28830                 ndr->depth++;
28831                 ndr_print_ptr(ndr, "servername", r->in.servername);
28832                 ndr->depth++;
28833                 if (r->in.servername) {
28834                         ndr_print_string(ndr, "servername", r->in.servername);
28835                 }
28836                 ndr->depth--;
28837                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28838                 ndr->depth++;
28839                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28840                 ndr->depth--;
28841                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
28842                 ndr->depth--;
28843         }
28844         if (flags & NDR_OUT) {
28845                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
28846                 ndr->depth++;
28847                 ndr_print_WERROR(ndr, "result", r->out.result);
28848                 ndr->depth--;
28849         }
28850         ndr->depth--;
28851 }
28852
28853 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
28854 {
28855         if (flags & NDR_IN) {
28856         }
28857         if (flags & NDR_OUT) {
28858                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28859         }
28860         return NDR_ERR_SUCCESS;
28861 }
28862
28863 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
28864 {
28865         if (flags & NDR_IN) {
28866         }
28867         if (flags & NDR_OUT) {
28868                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28869         }
28870         return NDR_ERR_SUCCESS;
28871 }
28872
28873 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
28874 {
28875         ndr_print_struct(ndr, name, "spoolss_5a");
28876         ndr->depth++;
28877         if (flags & NDR_SET_VALUES) {
28878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28879         }
28880         if (flags & NDR_IN) {
28881                 ndr_print_struct(ndr, "in", "spoolss_5a");
28882                 ndr->depth++;
28883                 ndr->depth--;
28884         }
28885         if (flags & NDR_OUT) {
28886                 ndr_print_struct(ndr, "out", "spoolss_5a");
28887                 ndr->depth++;
28888                 ndr_print_WERROR(ndr, "result", r->out.result);
28889                 ndr->depth--;
28890         }
28891         ndr->depth--;
28892 }
28893
28894 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
28895 {
28896         if (flags & NDR_IN) {
28897         }
28898         if (flags & NDR_OUT) {
28899                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28900         }
28901         return NDR_ERR_SUCCESS;
28902 }
28903
28904 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
28905 {
28906         if (flags & NDR_IN) {
28907         }
28908         if (flags & NDR_OUT) {
28909                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28910         }
28911         return NDR_ERR_SUCCESS;
28912 }
28913
28914 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
28915 {
28916         ndr_print_struct(ndr, name, "spoolss_5b");
28917         ndr->depth++;
28918         if (flags & NDR_SET_VALUES) {
28919                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28920         }
28921         if (flags & NDR_IN) {
28922                 ndr_print_struct(ndr, "in", "spoolss_5b");
28923                 ndr->depth++;
28924                 ndr->depth--;
28925         }
28926         if (flags & NDR_OUT) {
28927                 ndr_print_struct(ndr, "out", "spoolss_5b");
28928                 ndr->depth++;
28929                 ndr_print_WERROR(ndr, "result", r->out.result);
28930                 ndr->depth--;
28931         }
28932         ndr->depth--;
28933 }
28934
28935 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
28936 {
28937         if (flags & NDR_IN) {
28938         }
28939         if (flags & NDR_OUT) {
28940                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28941         }
28942         return NDR_ERR_SUCCESS;
28943 }
28944
28945 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
28946 {
28947         if (flags & NDR_IN) {
28948         }
28949         if (flags & NDR_OUT) {
28950                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28951         }
28952         return NDR_ERR_SUCCESS;
28953 }
28954
28955 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
28956 {
28957         ndr_print_struct(ndr, name, "spoolss_5c");
28958         ndr->depth++;
28959         if (flags & NDR_SET_VALUES) {
28960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28961         }
28962         if (flags & NDR_IN) {
28963                 ndr_print_struct(ndr, "in", "spoolss_5c");
28964                 ndr->depth++;
28965                 ndr->depth--;
28966         }
28967         if (flags & NDR_OUT) {
28968                 ndr_print_struct(ndr, "out", "spoolss_5c");
28969                 ndr->depth++;
28970                 ndr_print_WERROR(ndr, "result", r->out.result);
28971                 ndr->depth--;
28972         }
28973         ndr->depth--;
28974 }
28975
28976 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
28977 {
28978         if (flags & NDR_IN) {
28979         }
28980         if (flags & NDR_OUT) {
28981                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28982         }
28983         return NDR_ERR_SUCCESS;
28984 }
28985
28986 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
28987 {
28988         if (flags & NDR_IN) {
28989         }
28990         if (flags & NDR_OUT) {
28991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28992         }
28993         return NDR_ERR_SUCCESS;
28994 }
28995
28996 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
28997 {
28998         ndr_print_struct(ndr, name, "spoolss_5d");
28999         ndr->depth++;
29000         if (flags & NDR_SET_VALUES) {
29001                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29002         }
29003         if (flags & NDR_IN) {
29004                 ndr_print_struct(ndr, "in", "spoolss_5d");
29005                 ndr->depth++;
29006                 ndr->depth--;
29007         }
29008         if (flags & NDR_OUT) {
29009                 ndr_print_struct(ndr, "out", "spoolss_5d");
29010                 ndr->depth++;
29011                 ndr_print_WERROR(ndr, "result", r->out.result);
29012                 ndr->depth--;
29013         }
29014         ndr->depth--;
29015 }
29016
29017 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29018 {
29019         if (flags & NDR_IN) {
29020         }
29021         if (flags & NDR_OUT) {
29022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29023         }
29024         return NDR_ERR_SUCCESS;
29025 }
29026
29027 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29028 {
29029         if (flags & NDR_IN) {
29030         }
29031         if (flags & NDR_OUT) {
29032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29033         }
29034         return NDR_ERR_SUCCESS;
29035 }
29036
29037 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29038 {
29039         ndr_print_struct(ndr, name, "spoolss_5e");
29040         ndr->depth++;
29041         if (flags & NDR_SET_VALUES) {
29042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29043         }
29044         if (flags & NDR_IN) {
29045                 ndr_print_struct(ndr, "in", "spoolss_5e");
29046                 ndr->depth++;
29047                 ndr->depth--;
29048         }
29049         if (flags & NDR_OUT) {
29050                 ndr_print_struct(ndr, "out", "spoolss_5e");
29051                 ndr->depth++;
29052                 ndr_print_WERROR(ndr, "result", r->out.result);
29053                 ndr->depth--;
29054         }
29055         ndr->depth--;
29056 }
29057
29058 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29059 {
29060         if (flags & NDR_IN) {
29061         }
29062         if (flags & NDR_OUT) {
29063                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29064         }
29065         return NDR_ERR_SUCCESS;
29066 }
29067
29068 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29069 {
29070         if (flags & NDR_IN) {
29071         }
29072         if (flags & NDR_OUT) {
29073                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29074         }
29075         return NDR_ERR_SUCCESS;
29076 }
29077
29078 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29079 {
29080         ndr_print_struct(ndr, name, "spoolss_5f");
29081         ndr->depth++;
29082         if (flags & NDR_SET_VALUES) {
29083                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29084         }
29085         if (flags & NDR_IN) {
29086                 ndr_print_struct(ndr, "in", "spoolss_5f");
29087                 ndr->depth++;
29088                 ndr->depth--;
29089         }
29090         if (flags & NDR_OUT) {
29091                 ndr_print_struct(ndr, "out", "spoolss_5f");
29092                 ndr->depth++;
29093                 ndr_print_WERROR(ndr, "result", r->out.result);
29094                 ndr->depth--;
29095         }
29096         ndr->depth--;
29097 }
29098
29099 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29100 {
29101         if (flags & NDR_IN) {
29102         }
29103         if (flags & NDR_OUT) {
29104                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29105         }
29106         return NDR_ERR_SUCCESS;
29107 }
29108
29109 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29110 {
29111         if (flags & NDR_IN) {
29112         }
29113         if (flags & NDR_OUT) {
29114                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29115         }
29116         return NDR_ERR_SUCCESS;
29117 }
29118
29119 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29120 {
29121         ndr_print_struct(ndr, name, "spoolss_60");
29122         ndr->depth++;
29123         if (flags & NDR_SET_VALUES) {
29124                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29125         }
29126         if (flags & NDR_IN) {
29127                 ndr_print_struct(ndr, "in", "spoolss_60");
29128                 ndr->depth++;
29129                 ndr->depth--;
29130         }
29131         if (flags & NDR_OUT) {
29132                 ndr_print_struct(ndr, "out", "spoolss_60");
29133                 ndr->depth++;
29134                 ndr_print_WERROR(ndr, "result", r->out.result);
29135                 ndr->depth--;
29136         }
29137         ndr->depth--;
29138 }
29139
29140 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29141 {
29142         if (flags & NDR_IN) {
29143         }
29144         if (flags & NDR_OUT) {
29145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29146         }
29147         return NDR_ERR_SUCCESS;
29148 }
29149
29150 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29151 {
29152         if (flags & NDR_IN) {
29153         }
29154         if (flags & NDR_OUT) {
29155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29156         }
29157         return NDR_ERR_SUCCESS;
29158 }
29159
29160 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29161 {
29162         ndr_print_struct(ndr, name, "spoolss_61");
29163         ndr->depth++;
29164         if (flags & NDR_SET_VALUES) {
29165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29166         }
29167         if (flags & NDR_IN) {
29168                 ndr_print_struct(ndr, "in", "spoolss_61");
29169                 ndr->depth++;
29170                 ndr->depth--;
29171         }
29172         if (flags & NDR_OUT) {
29173                 ndr_print_struct(ndr, "out", "spoolss_61");
29174                 ndr->depth++;
29175                 ndr_print_WERROR(ndr, "result", r->out.result);
29176                 ndr->depth--;
29177         }
29178         ndr->depth--;
29179 }
29180
29181 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29182 {
29183         if (flags & NDR_IN) {
29184         }
29185         if (flags & NDR_OUT) {
29186                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29187         }
29188         return NDR_ERR_SUCCESS;
29189 }
29190
29191 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29192 {
29193         if (flags & NDR_IN) {
29194         }
29195         if (flags & NDR_OUT) {
29196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29197         }
29198         return NDR_ERR_SUCCESS;
29199 }
29200
29201 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29202 {
29203         ndr_print_struct(ndr, name, "spoolss_62");
29204         ndr->depth++;
29205         if (flags & NDR_SET_VALUES) {
29206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29207         }
29208         if (flags & NDR_IN) {
29209                 ndr_print_struct(ndr, "in", "spoolss_62");
29210                 ndr->depth++;
29211                 ndr->depth--;
29212         }
29213         if (flags & NDR_OUT) {
29214                 ndr_print_struct(ndr, "out", "spoolss_62");
29215                 ndr->depth++;
29216                 ndr_print_WERROR(ndr, "result", r->out.result);
29217                 ndr->depth--;
29218         }
29219         ndr->depth--;
29220 }
29221
29222 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29223 {
29224         if (flags & NDR_IN) {
29225         }
29226         if (flags & NDR_OUT) {
29227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29228         }
29229         return NDR_ERR_SUCCESS;
29230 }
29231
29232 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29233 {
29234         if (flags & NDR_IN) {
29235         }
29236         if (flags & NDR_OUT) {
29237                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29238         }
29239         return NDR_ERR_SUCCESS;
29240 }
29241
29242 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29243 {
29244         ndr_print_struct(ndr, name, "spoolss_63");
29245         ndr->depth++;
29246         if (flags & NDR_SET_VALUES) {
29247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29248         }
29249         if (flags & NDR_IN) {
29250                 ndr_print_struct(ndr, "in", "spoolss_63");
29251                 ndr->depth++;
29252                 ndr->depth--;
29253         }
29254         if (flags & NDR_OUT) {
29255                 ndr_print_struct(ndr, "out", "spoolss_63");
29256                 ndr->depth++;
29257                 ndr_print_WERROR(ndr, "result", r->out.result);
29258                 ndr->depth--;
29259         }
29260         ndr->depth--;
29261 }
29262
29263 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29264 {
29265         if (flags & NDR_IN) {
29266         }
29267         if (flags & NDR_OUT) {
29268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29269         }
29270         return NDR_ERR_SUCCESS;
29271 }
29272
29273 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29274 {
29275         if (flags & NDR_IN) {
29276         }
29277         if (flags & NDR_OUT) {
29278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29279         }
29280         return NDR_ERR_SUCCESS;
29281 }
29282
29283 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29284 {
29285         ndr_print_struct(ndr, name, "spoolss_64");
29286         ndr->depth++;
29287         if (flags & NDR_SET_VALUES) {
29288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29289         }
29290         if (flags & NDR_IN) {
29291                 ndr_print_struct(ndr, "in", "spoolss_64");
29292                 ndr->depth++;
29293                 ndr->depth--;
29294         }
29295         if (flags & NDR_OUT) {
29296                 ndr_print_struct(ndr, "out", "spoolss_64");
29297                 ndr->depth++;
29298                 ndr_print_WERROR(ndr, "result", r->out.result);
29299                 ndr->depth--;
29300         }
29301         ndr->depth--;
29302 }
29303
29304 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29305 {
29306         if (flags & NDR_IN) {
29307         }
29308         if (flags & NDR_OUT) {
29309                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29310         }
29311         return NDR_ERR_SUCCESS;
29312 }
29313
29314 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29315 {
29316         if (flags & NDR_IN) {
29317         }
29318         if (flags & NDR_OUT) {
29319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29320         }
29321         return NDR_ERR_SUCCESS;
29322 }
29323
29324 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29325 {
29326         ndr_print_struct(ndr, name, "spoolss_65");
29327         ndr->depth++;
29328         if (flags & NDR_SET_VALUES) {
29329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29330         }
29331         if (flags & NDR_IN) {
29332                 ndr_print_struct(ndr, "in", "spoolss_65");
29333                 ndr->depth++;
29334                 ndr->depth--;
29335         }
29336         if (flags & NDR_OUT) {
29337                 ndr_print_struct(ndr, "out", "spoolss_65");
29338                 ndr->depth++;
29339                 ndr_print_WERROR(ndr, "result", r->out.result);
29340                 ndr->depth--;
29341         }
29342         ndr->depth--;
29343 }
29344
29345 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29346 {
29347         uint32_t cntr_core_printer_drivers_1;
29348         if (flags & NDR_IN) {
29349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29350                 if (r->in.servername) {
29351                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29352                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29353                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29354                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29355                 }
29356                 if (r->in.architecture == NULL) {
29357                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29358                 }
29359                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29360                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29361                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29362                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29364                 if (r->in.core_driver_dependencies == NULL) {
29365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29366                 }
29367                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29368                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29370         }
29371         if (flags & NDR_OUT) {
29372                 if (r->out.core_printer_drivers == NULL) {
29373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29374                 }
29375                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29376                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29377                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29378                 }
29379                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29380         }
29381         return NDR_ERR_SUCCESS;
29382 }
29383
29384 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29385 {
29386         uint32_t _ptr_servername;
29387         uint32_t cntr_core_printer_drivers_1;
29388         TALLOC_CTX *_mem_save_servername_0;
29389         TALLOC_CTX *_mem_save_core_printer_drivers_1;
29390         if (flags & NDR_IN) {
29391                 ZERO_STRUCT(r->out);
29392
29393                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29394                 if (_ptr_servername) {
29395                         NDR_PULL_ALLOC(ndr, r->in.servername);
29396                 } else {
29397                         r->in.servername = NULL;
29398                 }
29399                 if (r->in.servername) {
29400                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29401                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29404                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29405                                 return 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));
29406                         }
29407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29408                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29410                 }
29411                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29412                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29413                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29414                         return 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));
29415                 }
29416                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29417                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29419                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29420                 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));
29421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29422                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29423                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29424                 if (r->in.core_driver_dependencies) {
29425                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29426                 }
29427         }
29428         if (flags & NDR_OUT) {
29429                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29430                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29431                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29432                 }
29433                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29434                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29435                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29436                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29437                 }
29438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29439                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29440                 if (r->out.core_printer_drivers) {
29441                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29442                 }
29443         }
29444         return NDR_ERR_SUCCESS;
29445 }
29446
29447 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29448 {
29449         uint32_t cntr_core_printer_drivers_1;
29450         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29451         ndr->depth++;
29452         if (flags & NDR_SET_VALUES) {
29453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29454         }
29455         if (flags & NDR_IN) {
29456                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29457                 ndr->depth++;
29458                 ndr_print_ptr(ndr, "servername", r->in.servername);
29459                 ndr->depth++;
29460                 if (r->in.servername) {
29461                         ndr_print_string(ndr, "servername", r->in.servername);
29462                 }
29463                 ndr->depth--;
29464                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29465                 ndr->depth++;
29466                 ndr_print_string(ndr, "architecture", r->in.architecture);
29467                 ndr->depth--;
29468                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
29469                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29470                 ndr->depth++;
29471                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29472                 ndr->depth--;
29473                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
29474                 ndr->depth--;
29475         }
29476         if (flags & NDR_OUT) {
29477                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
29478                 ndr->depth++;
29479                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
29480                 ndr->depth++;
29481                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
29482                 ndr->depth++;
29483                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
29484                         char *idx_1=NULL;
29485                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
29486                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
29487                                 free(idx_1);
29488                         }
29489                 }
29490                 ndr->depth--;
29491                 ndr->depth--;
29492                 ndr_print_WERROR(ndr, "result", r->out.result);
29493                 ndr->depth--;
29494         }
29495         ndr->depth--;
29496 }
29497
29498 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
29499 {
29500         if (flags & NDR_IN) {
29501         }
29502         if (flags & NDR_OUT) {
29503                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29504         }
29505         return NDR_ERR_SUCCESS;
29506 }
29507
29508 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
29509 {
29510         if (flags & NDR_IN) {
29511         }
29512         if (flags & NDR_OUT) {
29513                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29514         }
29515         return NDR_ERR_SUCCESS;
29516 }
29517
29518 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
29519 {
29520         ndr_print_struct(ndr, name, "spoolss_67");
29521         ndr->depth++;
29522         if (flags & NDR_SET_VALUES) {
29523                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29524         }
29525         if (flags & NDR_IN) {
29526                 ndr_print_struct(ndr, "in", "spoolss_67");
29527                 ndr->depth++;
29528                 ndr->depth--;
29529         }
29530         if (flags & NDR_OUT) {
29531                 ndr_print_struct(ndr, "out", "spoolss_67");
29532                 ndr->depth++;
29533                 ndr_print_WERROR(ndr, "result", r->out.result);
29534                 ndr->depth--;
29535         }
29536         ndr->depth--;
29537 }
29538
29539 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29540 {
29541         if (flags & NDR_IN) {
29542                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29543                 if (r->in.servername) {
29544                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29545                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29547                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29548                 }
29549                 if (r->in.architecture == NULL) {
29550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29551                 }
29552                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29553                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29554                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29555                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29557                 if (r->in.language) {
29558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29559                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29562                 }
29563                 if (r->in.package_id == NULL) {
29564                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29565                 }
29566                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29567                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29568                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29569                 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));
29570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29571                 if (r->in.driver_package_cab) {
29572                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29573                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29574                 }
29575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29576         }
29577         if (flags & NDR_OUT) {
29578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29579                 if (r->out.driver_package_cab) {
29580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29581                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29582                 }
29583                 if (r->out.required == NULL) {
29584                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29585                 }
29586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29587                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29588         }
29589         return NDR_ERR_SUCCESS;
29590 }
29591
29592 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29593 {
29594         uint32_t _ptr_servername;
29595         uint32_t _ptr_language;
29596         uint32_t _ptr_driver_package_cab;
29597         TALLOC_CTX *_mem_save_servername_0;
29598         TALLOC_CTX *_mem_save_language_0;
29599         TALLOC_CTX *_mem_save_driver_package_cab_0;
29600         TALLOC_CTX *_mem_save_required_0;
29601         if (flags & NDR_IN) {
29602                 ZERO_STRUCT(r->out);
29603
29604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29605                 if (_ptr_servername) {
29606                         NDR_PULL_ALLOC(ndr, r->in.servername);
29607                 } else {
29608                         r->in.servername = NULL;
29609                 }
29610                 if (r->in.servername) {
29611                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29612                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29615                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29616                                 return 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));
29617                         }
29618                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29619                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29621                 }
29622                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29623                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29624                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29625                         return 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));
29626                 }
29627                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29628                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
29630                 if (_ptr_language) {
29631                         NDR_PULL_ALLOC(ndr, r->in.language);
29632                 } else {
29633                         r->in.language = NULL;
29634                 }
29635                 if (r->in.language) {
29636                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
29637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
29638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
29639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
29640                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
29641                                 return 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));
29642                         }
29643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
29644                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
29645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
29646                 }
29647                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
29648                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
29649                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
29650                         return 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));
29651                 }
29652                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
29653                 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));
29654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29655                 if (_ptr_driver_package_cab) {
29656                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
29657                 } else {
29658                         r->in.driver_package_cab = NULL;
29659                 }
29660                 if (r->in.driver_package_cab) {
29661                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29662                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
29663                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
29664                         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));
29665                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29666                 }
29667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
29668                 NDR_PULL_ALLOC(ndr, r->out.required);
29669                 ZERO_STRUCTP(r->out.required);
29670                 if (r->in.driver_package_cab) {
29671                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
29672                 }
29673         }
29674         if (flags & NDR_OUT) {
29675                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29676                 if (_ptr_driver_package_cab) {
29677                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
29678                 } else {
29679                         r->out.driver_package_cab = NULL;
29680                 }
29681                 if (r->out.driver_package_cab) {
29682                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29683                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
29684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
29685                         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));
29686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29687                 }
29688                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29689                         NDR_PULL_ALLOC(ndr, r->out.required);
29690                 }
29691                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
29692                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
29693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
29694                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
29695                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29696                 if (r->out.driver_package_cab) {
29697                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
29698                 }
29699         }
29700         return NDR_ERR_SUCCESS;
29701 }
29702
29703 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29704 {
29705         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
29706         ndr->depth++;
29707         if (flags & NDR_SET_VALUES) {
29708                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29709         }
29710         if (flags & NDR_IN) {
29711                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
29712                 ndr->depth++;
29713                 ndr_print_ptr(ndr, "servername", r->in.servername);
29714                 ndr->depth++;
29715                 if (r->in.servername) {
29716                         ndr_print_string(ndr, "servername", r->in.servername);
29717                 }
29718                 ndr->depth--;
29719                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29720                 ndr->depth++;
29721                 ndr_print_string(ndr, "architecture", r->in.architecture);
29722                 ndr->depth--;
29723                 ndr_print_ptr(ndr, "language", r->in.language);
29724                 ndr->depth++;
29725                 if (r->in.language) {
29726                         ndr_print_string(ndr, "language", r->in.language);
29727                 }
29728                 ndr->depth--;
29729                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
29730                 ndr->depth++;
29731                 ndr_print_string(ndr, "package_id", r->in.package_id);
29732                 ndr->depth--;
29733                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
29734                 ndr->depth++;
29735                 if (r->in.driver_package_cab) {
29736                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
29737                 }
29738                 ndr->depth--;
29739                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
29740                 ndr->depth--;
29741         }
29742         if (flags & NDR_OUT) {
29743                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
29744                 ndr->depth++;
29745                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
29746                 ndr->depth++;
29747                 if (r->out.driver_package_cab) {
29748                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
29749                 }
29750                 ndr->depth--;
29751                 ndr_print_ptr(ndr, "required", r->out.required);
29752                 ndr->depth++;
29753                 ndr_print_uint32(ndr, "required", *r->out.required);
29754                 ndr->depth--;
29755                 ndr_print_WERROR(ndr, "result", r->out.result);
29756                 ndr->depth--;
29757         }
29758         ndr->depth--;
29759 }
29760
29761 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
29762 {
29763         if (flags & NDR_IN) {
29764         }
29765         if (flags & NDR_OUT) {
29766                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29767         }
29768         return NDR_ERR_SUCCESS;
29769 }
29770
29771 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
29772 {
29773         if (flags & NDR_IN) {
29774         }
29775         if (flags & NDR_OUT) {
29776                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29777         }
29778         return NDR_ERR_SUCCESS;
29779 }
29780
29781 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
29782 {
29783         ndr_print_struct(ndr, name, "spoolss_69");
29784         ndr->depth++;
29785         if (flags & NDR_SET_VALUES) {
29786                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29787         }
29788         if (flags & NDR_IN) {
29789                 ndr_print_struct(ndr, "in", "spoolss_69");
29790                 ndr->depth++;
29791                 ndr->depth--;
29792         }
29793         if (flags & NDR_OUT) {
29794                 ndr_print_struct(ndr, "out", "spoolss_69");
29795                 ndr->depth++;
29796                 ndr_print_WERROR(ndr, "result", r->out.result);
29797                 ndr->depth--;
29798         }
29799         ndr->depth--;
29800 }
29801
29802 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
29803 {
29804         if (flags & NDR_IN) {
29805         }
29806         if (flags & NDR_OUT) {
29807                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29808         }
29809         return NDR_ERR_SUCCESS;
29810 }
29811
29812 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
29813 {
29814         if (flags & NDR_IN) {
29815         }
29816         if (flags & NDR_OUT) {
29817                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29818         }
29819         return NDR_ERR_SUCCESS;
29820 }
29821
29822 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
29823 {
29824         ndr_print_struct(ndr, name, "spoolss_6a");
29825         ndr->depth++;
29826         if (flags & NDR_SET_VALUES) {
29827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29828         }
29829         if (flags & NDR_IN) {
29830                 ndr_print_struct(ndr, "in", "spoolss_6a");
29831                 ndr->depth++;
29832                 ndr->depth--;
29833         }
29834         if (flags & NDR_OUT) {
29835                 ndr_print_struct(ndr, "out", "spoolss_6a");
29836                 ndr->depth++;
29837                 ndr_print_WERROR(ndr, "result", r->out.result);
29838                 ndr->depth--;
29839         }
29840         ndr->depth--;
29841 }
29842
29843 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
29844 {
29845         if (flags & NDR_IN) {
29846         }
29847         if (flags & NDR_OUT) {
29848                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29849         }
29850         return NDR_ERR_SUCCESS;
29851 }
29852
29853 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
29854 {
29855         if (flags & NDR_IN) {
29856         }
29857         if (flags & NDR_OUT) {
29858                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29859         }
29860         return NDR_ERR_SUCCESS;
29861 }
29862
29863 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
29864 {
29865         ndr_print_struct(ndr, name, "spoolss_6b");
29866         ndr->depth++;
29867         if (flags & NDR_SET_VALUES) {
29868                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29869         }
29870         if (flags & NDR_IN) {
29871                 ndr_print_struct(ndr, "in", "spoolss_6b");
29872                 ndr->depth++;
29873                 ndr->depth--;
29874         }
29875         if (flags & NDR_OUT) {
29876                 ndr_print_struct(ndr, "out", "spoolss_6b");
29877                 ndr->depth++;
29878                 ndr_print_WERROR(ndr, "result", r->out.result);
29879                 ndr->depth--;
29880         }
29881         ndr->depth--;
29882 }
29883
29884 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
29885 {
29886         if (flags & NDR_IN) {
29887         }
29888         if (flags & NDR_OUT) {
29889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29890         }
29891         return NDR_ERR_SUCCESS;
29892 }
29893
29894 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
29895 {
29896         if (flags & NDR_IN) {
29897         }
29898         if (flags & NDR_OUT) {
29899                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29900         }
29901         return NDR_ERR_SUCCESS;
29902 }
29903
29904 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
29905 {
29906         ndr_print_struct(ndr, name, "spoolss_6c");
29907         ndr->depth++;
29908         if (flags & NDR_SET_VALUES) {
29909                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29910         }
29911         if (flags & NDR_IN) {
29912                 ndr_print_struct(ndr, "in", "spoolss_6c");
29913                 ndr->depth++;
29914                 ndr->depth--;
29915         }
29916         if (flags & NDR_OUT) {
29917                 ndr_print_struct(ndr, "out", "spoolss_6c");
29918                 ndr->depth++;
29919                 ndr_print_WERROR(ndr, "result", r->out.result);
29920                 ndr->depth--;
29921         }
29922         ndr->depth--;
29923 }
29924
29925 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
29926 {
29927         if (flags & NDR_IN) {
29928         }
29929         if (flags & NDR_OUT) {
29930                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29931         }
29932         return NDR_ERR_SUCCESS;
29933 }
29934
29935 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
29936 {
29937         if (flags & NDR_IN) {
29938         }
29939         if (flags & NDR_OUT) {
29940                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29941         }
29942         return NDR_ERR_SUCCESS;
29943 }
29944
29945 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
29946 {
29947         ndr_print_struct(ndr, name, "spoolss_6d");
29948         ndr->depth++;
29949         if (flags & NDR_SET_VALUES) {
29950                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29951         }
29952         if (flags & NDR_IN) {
29953                 ndr_print_struct(ndr, "in", "spoolss_6d");
29954                 ndr->depth++;
29955                 ndr->depth--;
29956         }
29957         if (flags & NDR_OUT) {
29958                 ndr_print_struct(ndr, "out", "spoolss_6d");
29959                 ndr->depth++;
29960                 ndr_print_WERROR(ndr, "result", r->out.result);
29961                 ndr->depth--;
29962         }
29963         ndr->depth--;
29964 }
29965
29966 static const struct ndr_interface_call spoolss_calls[] = {
29967         {
29968                 "spoolss_EnumPrinters",
29969                 sizeof(struct spoolss_EnumPrinters),
29970                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
29971                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
29972                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
29973                 false,
29974         },
29975         {
29976                 "spoolss_OpenPrinter",
29977                 sizeof(struct spoolss_OpenPrinter),
29978                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
29979                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
29980                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
29981                 false,
29982         },
29983         {
29984                 "spoolss_SetJob",
29985                 sizeof(struct spoolss_SetJob),
29986                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
29987                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
29988                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
29989                 false,
29990         },
29991         {
29992                 "spoolss_GetJob",
29993                 sizeof(struct spoolss_GetJob),
29994                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
29995                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
29996                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
29997                 false,
29998         },
29999         {
30000                 "spoolss_EnumJobs",
30001                 sizeof(struct spoolss_EnumJobs),
30002                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30003                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30004                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30005                 false,
30006         },
30007         {
30008                 "spoolss_AddPrinter",
30009                 sizeof(struct spoolss_AddPrinter),
30010                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30011                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30012                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30013                 false,
30014         },
30015         {
30016                 "spoolss_DeletePrinter",
30017                 sizeof(struct spoolss_DeletePrinter),
30018                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30019                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30020                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30021                 false,
30022         },
30023         {
30024                 "spoolss_SetPrinter",
30025                 sizeof(struct spoolss_SetPrinter),
30026                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30027                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30028                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30029                 false,
30030         },
30031         {
30032                 "spoolss_GetPrinter",
30033                 sizeof(struct spoolss_GetPrinter),
30034                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30035                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30036                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30037                 false,
30038         },
30039         {
30040                 "spoolss_AddPrinterDriver",
30041                 sizeof(struct spoolss_AddPrinterDriver),
30042                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30043                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30044                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30045                 false,
30046         },
30047         {
30048                 "spoolss_EnumPrinterDrivers",
30049                 sizeof(struct spoolss_EnumPrinterDrivers),
30050                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30051                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30052                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30053                 false,
30054         },
30055         {
30056                 "spoolss_GetPrinterDriver",
30057                 sizeof(struct spoolss_GetPrinterDriver),
30058                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30059                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30060                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30061                 false,
30062         },
30063         {
30064                 "spoolss_GetPrinterDriverDirectory",
30065                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30066                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30067                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30068                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30069                 false,
30070         },
30071         {
30072                 "spoolss_DeletePrinterDriver",
30073                 sizeof(struct spoolss_DeletePrinterDriver),
30074                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30075                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30076                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30077                 false,
30078         },
30079         {
30080                 "spoolss_AddPrintProcessor",
30081                 sizeof(struct spoolss_AddPrintProcessor),
30082                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30083                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30084                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30085                 false,
30086         },
30087         {
30088                 "spoolss_EnumPrintProcessors",
30089                 sizeof(struct spoolss_EnumPrintProcessors),
30090                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30091                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30092                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30093                 false,
30094         },
30095         {
30096                 "spoolss_GetPrintProcessorDirectory",
30097                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30098                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30099                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30100                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30101                 false,
30102         },
30103         {
30104                 "spoolss_StartDocPrinter",
30105                 sizeof(struct spoolss_StartDocPrinter),
30106                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30107                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30108                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30109                 false,
30110         },
30111         {
30112                 "spoolss_StartPagePrinter",
30113                 sizeof(struct spoolss_StartPagePrinter),
30114                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30115                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30116                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30117                 false,
30118         },
30119         {
30120                 "spoolss_WritePrinter",
30121                 sizeof(struct spoolss_WritePrinter),
30122                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30123                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30124                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30125                 false,
30126         },
30127         {
30128                 "spoolss_EndPagePrinter",
30129                 sizeof(struct spoolss_EndPagePrinter),
30130                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30131                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30132                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30133                 false,
30134         },
30135         {
30136                 "spoolss_AbortPrinter",
30137                 sizeof(struct spoolss_AbortPrinter),
30138                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30139                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30140                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30141                 false,
30142         },
30143         {
30144                 "spoolss_ReadPrinter",
30145                 sizeof(struct spoolss_ReadPrinter),
30146                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30147                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30148                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30149                 false,
30150         },
30151         {
30152                 "spoolss_EndDocPrinter",
30153                 sizeof(struct spoolss_EndDocPrinter),
30154                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30155                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30156                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30157                 false,
30158         },
30159         {
30160                 "spoolss_AddJob",
30161                 sizeof(struct spoolss_AddJob),
30162                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30163                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30164                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
30165                 false,
30166         },
30167         {
30168                 "spoolss_ScheduleJob",
30169                 sizeof(struct spoolss_ScheduleJob),
30170                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30171                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30172                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30173                 false,
30174         },
30175         {
30176                 "spoolss_GetPrinterData",
30177                 sizeof(struct spoolss_GetPrinterData),
30178                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30179                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30180                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30181                 false,
30182         },
30183         {
30184                 "spoolss_SetPrinterData",
30185                 sizeof(struct spoolss_SetPrinterData),
30186                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30187                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30188                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30189                 false,
30190         },
30191         {
30192                 "spoolss_WaitForPrinterChange",
30193                 sizeof(struct spoolss_WaitForPrinterChange),
30194                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30195                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30196                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30197                 false,
30198         },
30199         {
30200                 "spoolss_ClosePrinter",
30201                 sizeof(struct spoolss_ClosePrinter),
30202                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30203                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30204                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30205                 false,
30206         },
30207         {
30208                 "spoolss_AddForm",
30209                 sizeof(struct spoolss_AddForm),
30210                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30211                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30212                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
30213                 false,
30214         },
30215         {
30216                 "spoolss_DeleteForm",
30217                 sizeof(struct spoolss_DeleteForm),
30218                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30219                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30220                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30221                 false,
30222         },
30223         {
30224                 "spoolss_GetForm",
30225                 sizeof(struct spoolss_GetForm),
30226                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30227                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30228                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
30229                 false,
30230         },
30231         {
30232                 "spoolss_SetForm",
30233                 sizeof(struct spoolss_SetForm),
30234                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30235                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30236                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
30237                 false,
30238         },
30239         {
30240                 "spoolss_EnumForms",
30241                 sizeof(struct spoolss_EnumForms),
30242                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30243                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30244                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30245                 false,
30246         },
30247         {
30248                 "spoolss_EnumPorts",
30249                 sizeof(struct spoolss_EnumPorts),
30250                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30251                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30252                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30253                 false,
30254         },
30255         {
30256                 "spoolss_EnumMonitors",
30257                 sizeof(struct spoolss_EnumMonitors),
30258                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30259                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30260                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30261                 false,
30262         },
30263         {
30264                 "spoolss_AddPort",
30265                 sizeof(struct spoolss_AddPort),
30266                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30267                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30268                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30269                 false,
30270         },
30271         {
30272                 "spoolss_ConfigurePort",
30273                 sizeof(struct spoolss_ConfigurePort),
30274                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30275                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30276                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30277                 false,
30278         },
30279         {
30280                 "spoolss_DeletePort",
30281                 sizeof(struct spoolss_DeletePort),
30282                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30283                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30284                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30285                 false,
30286         },
30287         {
30288                 "spoolss_CreatePrinterIC",
30289                 sizeof(struct spoolss_CreatePrinterIC),
30290                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30291                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30292                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30293                 false,
30294         },
30295         {
30296                 "spoolss_PlayGDIScriptOnPrinterIC",
30297                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30298                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30299                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30300                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30301                 false,
30302         },
30303         {
30304                 "spoolss_DeletePrinterIC",
30305                 sizeof(struct spoolss_DeletePrinterIC),
30306                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30307                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30308                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30309                 false,
30310         },
30311         {
30312                 "spoolss_AddPrinterConnection",
30313                 sizeof(struct spoolss_AddPrinterConnection),
30314                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30315                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30316                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30317                 false,
30318         },
30319         {
30320                 "spoolss_DeletePrinterConnection",
30321                 sizeof(struct spoolss_DeletePrinterConnection),
30322                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30323                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30324                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30325                 false,
30326         },
30327         {
30328                 "spoolss_PrinterMessageBox",
30329                 sizeof(struct spoolss_PrinterMessageBox),
30330                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30331                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30332                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30333                 false,
30334         },
30335         {
30336                 "spoolss_AddMonitor",
30337                 sizeof(struct spoolss_AddMonitor),
30338                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30339                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30340                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30341                 false,
30342         },
30343         {
30344                 "spoolss_DeleteMonitor",
30345                 sizeof(struct spoolss_DeleteMonitor),
30346                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30347                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30348                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30349                 false,
30350         },
30351         {
30352                 "spoolss_DeletePrintProcessor",
30353                 sizeof(struct spoolss_DeletePrintProcessor),
30354                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30355                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30356                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30357                 false,
30358         },
30359         {
30360                 "spoolss_AddPrintProvidor",
30361                 sizeof(struct spoolss_AddPrintProvidor),
30362                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30363                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30364                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30365                 false,
30366         },
30367         {
30368                 "spoolss_DeletePrintProvidor",
30369                 sizeof(struct spoolss_DeletePrintProvidor),
30370                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30371                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30372                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30373                 false,
30374         },
30375         {
30376                 "spoolss_EnumPrintProcDataTypes",
30377                 sizeof(struct spoolss_EnumPrintProcDataTypes),
30378                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30379                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30380                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30381                 false,
30382         },
30383         {
30384                 "spoolss_ResetPrinter",
30385                 sizeof(struct spoolss_ResetPrinter),
30386                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30387                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30388                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30389                 false,
30390         },
30391         {
30392                 "spoolss_GetPrinterDriver2",
30393                 sizeof(struct spoolss_GetPrinterDriver2),
30394                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30395                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30396                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30397                 false,
30398         },
30399         {
30400                 "spoolss_FindFirstPrinterChangeNotification",
30401                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30402                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30403                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30404                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30405                 false,
30406         },
30407         {
30408                 "spoolss_FindNextPrinterChangeNotification",
30409                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
30410                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30411                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30412                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30413                 false,
30414         },
30415         {
30416                 "spoolss_FindClosePrinterNotify",
30417                 sizeof(struct spoolss_FindClosePrinterNotify),
30418                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30419                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30420                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30421                 false,
30422         },
30423         {
30424                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30425                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30426                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30427                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30428                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30429                 false,
30430         },
30431         {
30432                 "spoolss_ReplyOpenPrinter",
30433                 sizeof(struct spoolss_ReplyOpenPrinter),
30434                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30435                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30436                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30437                 false,
30438         },
30439         {
30440                 "spoolss_RouterReplyPrinter",
30441                 sizeof(struct spoolss_RouterReplyPrinter),
30442                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30443                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30444                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30445                 false,
30446         },
30447         {
30448                 "spoolss_ReplyClosePrinter",
30449                 sizeof(struct spoolss_ReplyClosePrinter),
30450                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30451                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30452                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30453                 false,
30454         },
30455         {
30456                 "spoolss_AddPortEx",
30457                 sizeof(struct spoolss_AddPortEx),
30458                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30459                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30460                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30461                 false,
30462         },
30463         {
30464                 "spoolss_RouterFindFirstPrinterChangeNotification",
30465                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30466                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30467                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30468                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
30469                 false,
30470         },
30471         {
30472                 "spoolss_SpoolerInit",
30473                 sizeof(struct spoolss_SpoolerInit),
30474                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
30475                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
30476                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
30477                 false,
30478         },
30479         {
30480                 "spoolss_ResetPrinterEx",
30481                 sizeof(struct spoolss_ResetPrinterEx),
30482                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
30483                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
30484                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
30485                 false,
30486         },
30487         {
30488                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
30489                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
30490                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30491                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30492                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30493                 false,
30494         },
30495         {
30496                 "spoolss_RouterReplyPrinterEx",
30497                 sizeof(struct spoolss_RouterReplyPrinterEx),
30498                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
30499                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
30500                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
30501                 false,
30502         },
30503         {
30504                 "spoolss_RouterRefreshPrinterChangeNotify",
30505                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
30506                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
30507                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
30508                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
30509                 false,
30510         },
30511         {
30512                 "spoolss_44",
30513                 sizeof(struct spoolss_44),
30514                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
30515                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
30516                 (ndr_print_function_t) ndr_print_spoolss_44,
30517                 false,
30518         },
30519         {
30520                 "spoolss_OpenPrinterEx",
30521                 sizeof(struct spoolss_OpenPrinterEx),
30522                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
30523                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
30524                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
30525                 false,
30526         },
30527         {
30528                 "spoolss_AddPrinterEx",
30529                 sizeof(struct spoolss_AddPrinterEx),
30530                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
30531                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
30532                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
30533                 false,
30534         },
30535         {
30536                 "spoolss_47",
30537                 sizeof(struct spoolss_47),
30538                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
30539                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30540                 (ndr_print_function_t) ndr_print_spoolss_47,
30541                 false,
30542         },
30543         {
30544                 "spoolss_EnumPrinterData",
30545                 sizeof(struct spoolss_EnumPrinterData),
30546                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30547                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30548                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30549                 false,
30550         },
30551         {
30552                 "spoolss_DeletePrinterData",
30553                 sizeof(struct spoolss_DeletePrinterData),
30554                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30555                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30556                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30557                 false,
30558         },
30559         {
30560                 "spoolss_4a",
30561                 sizeof(struct spoolss_4a),
30562                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30563                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30564                 (ndr_print_function_t) ndr_print_spoolss_4a,
30565                 false,
30566         },
30567         {
30568                 "spoolss_4b",
30569                 sizeof(struct spoolss_4b),
30570                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30571                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30572                 (ndr_print_function_t) ndr_print_spoolss_4b,
30573                 false,
30574         },
30575         {
30576                 "spoolss_4c",
30577                 sizeof(struct spoolss_4c),
30578                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30579                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30580                 (ndr_print_function_t) ndr_print_spoolss_4c,
30581                 false,
30582         },
30583         {
30584                 "spoolss_SetPrinterDataEx",
30585                 sizeof(struct spoolss_SetPrinterDataEx),
30586                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30587                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30588                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30589                 false,
30590         },
30591         {
30592                 "spoolss_GetPrinterDataEx",
30593                 sizeof(struct spoolss_GetPrinterDataEx),
30594                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30595                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30596                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30597                 false,
30598         },
30599         {
30600                 "spoolss_EnumPrinterDataEx",
30601                 sizeof(struct spoolss_EnumPrinterDataEx),
30602                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30603                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30604                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30605                 false,
30606         },
30607         {
30608                 "spoolss_EnumPrinterKey",
30609                 sizeof(struct spoolss_EnumPrinterKey),
30610                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
30611                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
30612                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
30613                 false,
30614         },
30615         {
30616                 "spoolss_DeletePrinterDataEx",
30617                 sizeof(struct spoolss_DeletePrinterDataEx),
30618                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
30619                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
30620                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
30621                 false,
30622         },
30623         {
30624                 "spoolss_DeletePrinterKey",
30625                 sizeof(struct spoolss_DeletePrinterKey),
30626                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
30627                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
30628                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
30629                 false,
30630         },
30631         {
30632                 "spoolss_53",
30633                 sizeof(struct spoolss_53),
30634                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
30635                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
30636                 (ndr_print_function_t) ndr_print_spoolss_53,
30637                 false,
30638         },
30639         {
30640                 "spoolss_DeletePrinterDriverEx",
30641                 sizeof(struct spoolss_DeletePrinterDriverEx),
30642                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
30643                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
30644                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
30645                 false,
30646         },
30647         {
30648                 "spoolss_55",
30649                 sizeof(struct spoolss_55),
30650                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
30651                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
30652                 (ndr_print_function_t) ndr_print_spoolss_55,
30653                 false,
30654         },
30655         {
30656                 "spoolss_56",
30657                 sizeof(struct spoolss_56),
30658                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
30659                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
30660                 (ndr_print_function_t) ndr_print_spoolss_56,
30661                 false,
30662         },
30663         {
30664                 "spoolss_57",
30665                 sizeof(struct spoolss_57),
30666                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
30667                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
30668                 (ndr_print_function_t) ndr_print_spoolss_57,
30669                 false,
30670         },
30671         {
30672                 "spoolss_XcvData",
30673                 sizeof(struct spoolss_XcvData),
30674                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
30675                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
30676                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
30677                 false,
30678         },
30679         {
30680                 "spoolss_AddPrinterDriverEx",
30681                 sizeof(struct spoolss_AddPrinterDriverEx),
30682                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
30683                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
30684                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
30685                 false,
30686         },
30687         {
30688                 "spoolss_5a",
30689                 sizeof(struct spoolss_5a),
30690                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
30691                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
30692                 (ndr_print_function_t) ndr_print_spoolss_5a,
30693                 false,
30694         },
30695         {
30696                 "spoolss_5b",
30697                 sizeof(struct spoolss_5b),
30698                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
30699                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
30700                 (ndr_print_function_t) ndr_print_spoolss_5b,
30701                 false,
30702         },
30703         {
30704                 "spoolss_5c",
30705                 sizeof(struct spoolss_5c),
30706                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
30707                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
30708                 (ndr_print_function_t) ndr_print_spoolss_5c,
30709                 false,
30710         },
30711         {
30712                 "spoolss_5d",
30713                 sizeof(struct spoolss_5d),
30714                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
30715                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
30716                 (ndr_print_function_t) ndr_print_spoolss_5d,
30717                 false,
30718         },
30719         {
30720                 "spoolss_5e",
30721                 sizeof(struct spoolss_5e),
30722                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
30723                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
30724                 (ndr_print_function_t) ndr_print_spoolss_5e,
30725                 false,
30726         },
30727         {
30728                 "spoolss_5f",
30729                 sizeof(struct spoolss_5f),
30730                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
30731                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
30732                 (ndr_print_function_t) ndr_print_spoolss_5f,
30733                 false,
30734         },
30735         {
30736                 "spoolss_60",
30737                 sizeof(struct spoolss_60),
30738                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
30739                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
30740                 (ndr_print_function_t) ndr_print_spoolss_60,
30741                 false,
30742         },
30743         {
30744                 "spoolss_61",
30745                 sizeof(struct spoolss_61),
30746                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
30747                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
30748                 (ndr_print_function_t) ndr_print_spoolss_61,
30749                 false,
30750         },
30751         {
30752                 "spoolss_62",
30753                 sizeof(struct spoolss_62),
30754                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
30755                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
30756                 (ndr_print_function_t) ndr_print_spoolss_62,
30757                 false,
30758         },
30759         {
30760                 "spoolss_63",
30761                 sizeof(struct spoolss_63),
30762                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
30763                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
30764                 (ndr_print_function_t) ndr_print_spoolss_63,
30765                 false,
30766         },
30767         {
30768                 "spoolss_64",
30769                 sizeof(struct spoolss_64),
30770                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
30771                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
30772                 (ndr_print_function_t) ndr_print_spoolss_64,
30773                 false,
30774         },
30775         {
30776                 "spoolss_65",
30777                 sizeof(struct spoolss_65),
30778                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
30779                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
30780                 (ndr_print_function_t) ndr_print_spoolss_65,
30781                 false,
30782         },
30783         {
30784                 "spoolss_GetCorePrinterDrivers",
30785                 sizeof(struct spoolss_GetCorePrinterDrivers),
30786                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
30787                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
30788                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
30789                 false,
30790         },
30791         {
30792                 "spoolss_67",
30793                 sizeof(struct spoolss_67),
30794                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
30795                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
30796                 (ndr_print_function_t) ndr_print_spoolss_67,
30797                 false,
30798         },
30799         {
30800                 "spoolss_GetPrinterDriverPackagePath",
30801                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
30802                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
30803                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
30804                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
30805                 false,
30806         },
30807         {
30808                 "spoolss_69",
30809                 sizeof(struct spoolss_69),
30810                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
30811                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
30812                 (ndr_print_function_t) ndr_print_spoolss_69,
30813                 false,
30814         },
30815         {
30816                 "spoolss_6a",
30817                 sizeof(struct spoolss_6a),
30818                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
30819                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
30820                 (ndr_print_function_t) ndr_print_spoolss_6a,
30821                 false,
30822         },
30823         {
30824                 "spoolss_6b",
30825                 sizeof(struct spoolss_6b),
30826                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
30827                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
30828                 (ndr_print_function_t) ndr_print_spoolss_6b,
30829                 false,
30830         },
30831         {
30832                 "spoolss_6c",
30833                 sizeof(struct spoolss_6c),
30834                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
30835                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
30836                 (ndr_print_function_t) ndr_print_spoolss_6c,
30837                 false,
30838         },
30839         {
30840                 "spoolss_6d",
30841                 sizeof(struct spoolss_6d),
30842                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
30843                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
30844                 (ndr_print_function_t) ndr_print_spoolss_6d,
30845                 false,
30846         },
30847         { NULL, 0, NULL, NULL, NULL, false }
30848 };
30849
30850 static const char * const spoolss_endpoint_strings[] = {
30851         "ncacn_np:[\\pipe\\spoolss]",
30852 };
30853
30854 static const struct ndr_interface_string_array spoolss_endpoints = {
30855         .count  = 1,
30856         .names  = spoolss_endpoint_strings
30857 };
30858
30859 static const char * const spoolss_authservice_strings[] = {
30860         "host",
30861 };
30862
30863 static const struct ndr_interface_string_array spoolss_authservices = {
30864         .count  = 1,
30865         .names  = spoolss_authservice_strings
30866 };
30867
30868
30869 const struct ndr_interface_table ndr_table_spoolss = {
30870         .name           = "spoolss",
30871         .syntax_id      = {
30872                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
30873                 NDR_SPOOLSS_VERSION
30874         },
30875         .helpstring     = NDR_SPOOLSS_HELPSTRING,
30876         .num_calls      = 110,
30877         .calls          = spoolss_calls,
30878         .endpoints      = &spoolss_endpoints,
30879         .authservices   = &spoolss_authservices
30880 };
30881